import { i as __name } from "./rolldown-runtime.mjs";
import { a as LikeC4ProjectConfig, i as IncludeConfig, o as LikeC4ProjectConfigInput } from "./index.mjs";
import { t as Logger } from "./libs/@logtape/logtape.mjs";
import { $ as FileSystemProvider, A as DefaultValueConverter, B as AsyncDisposable, C as CodeLensParams, D as ValidationOptions, E as DefaultDocumentValidator, F as JSDocDocumentationProvider, G as Reference, H as AstNode, I as DefaultIndexManager, J as LangiumDocument, K as ReferenceInfo, L as ReferenceDescription, M as MaybePromise, N as DefaultScopeProvider, O as DiagnosticInfo, P as Scope, Q as FileSystemNode, R as DefaultNameProvider, S as CodeActionParams, T as DocumentSymbolParams, U as AstNodeDescription, V as Disposable$1, W as CstNode, X as PrecomputedScopes, Y as LangiumDocumentFactory, Z as Stream, _ as CodeLensProvider, _t as SymbolKind, a as LangiumServices, at as CodeAction, b as FileSelector, c as AbstractSemanticTokenProvider, ct as CompletionItemKind, d as AbstractFormatter, dt as DocumentLink, et as Keyword, f as FormattingRegion, ft as DocumentSymbol, g as DefaultDocumentHighlightProvider, gt as Range, h as DocumentLinkProvider, ht as Location, i as NextFeature, it as RequestType, j as ValueType, k as DefaultScopeComputation, l as SemanticTokenAcceptor, lt as Diagnostic, m as NodeKindProvider, mt as Hover, n as CompletionContext, nt as CancellationToken$1, o as LangiumSharedServices, ot as CodeLens, p as DocumentSymbolProvider, pt as FormattingOptions, q as DefaultLangiumDocuments, r as DefaultCompletionProvider, rt as NotificationType, s as DefaultWorkspaceSymbolProvider, st as Command, t as CompletionAcceptor, tt as URI, u as AstNodeHoverProvider, ut as DocumentHighlight, v as CodeActionProvider, vt as TextEdit, w as DocumentLinkParams, x as BuildOptions, y as DefaultWorkspaceManager, yt as WorkspaceFolder, z as WorkspaceCache } from "./libs/langium.mjs";
import { t as $keywords } from "./libs/@ts-graphviz/common.mjs";
import { LikeC4Styles } from "@likec4/core/styles";
import { EdgeId, Fqn, GuardedBy, LayoutedView, NodeId, NonEmptyArray, NonEmptyReadonlyArray, ProjectId, ViewId } from "@likec4/core/types";
import * as c4 from "@likec4/core";
import { AnyAux, ComputedView, DeploymentFqn, DiagramView, EdgeId as EdgeId$1, Fqn as Fqn$1, LayoutType, LayoutedView as LayoutedView$1, LikeC4Styles as LikeC4Styles$1, NonEmptyArray as NonEmptyArray$1, NonEmptyReadonlyArray as NonEmptyReadonlyArray$1, ProjectId as ProjectId$1, RelationId, Tag, UnknownComputed, UnknownLayouted, UnknownParsed, ViewChange, ViewId as ViewId$1, aux as aux$1 } from "@likec4/core";
import { DefaultWeakMap, MultiMap } from "@likec4/core/utils";
import { ElementModel, LikeC4Model } from "@likec4/core/model";
import { AdhocViewPredicate, ComputedProjectsView, LayoutedProjectsView } from "@likec4/core/compute-view";
import * as type_fest0 from "type-fest";
import { ConditionalPick, MergeExclusive, Simplify, Tagged, ValueOf, Writable } from "type-fest";

//#region ../layouts/dist/_chunks/types.d.mts
/**
 * invisible edge added by AI to enforce better layout
 */
interface AIEnforcementEdge {
  source: NodeId;
  target: NodeId;
  weight?: number;
  minlen?: number;
}
/**
 * Complete set of AI-generated layout hints.
 * This is the JSON schema the LLM must produce.
 */
interface AILayoutHints {
  direction?: 'TB' | 'BT' | 'LR' | 'RL';
  ranks: ReadonlyArray<{
    rank: 'same' | 'source' | 'sink' | 'min' | 'max';
    nodes: NonEmptyArray<NodeId>;
  }>;
  edgeWeight: Record<EdgeId, number>;
  edgeMinlen: Record<EdgeId, number>;
  /**
   * These edges should be reversed in DOT
   * Unique array of EdgeIds.
   */
  reverseRank?: NonEmptyReadonlyArray<EdgeId>;
  /**
   * These edges should be excluded, i.e. `constraint=false` in Graphviz, to allow more flexible layouts.
   * Unique array of EdgeIds.
   */
  excludeFromRanking?: NonEmptyReadonlyArray<EdgeId>;
  /**
   * Suggested order of edges for DOT output, to influence edge routing.
   */
  edgeOrder?: NonEmptyReadonlyArray<EdgeId>;
  /**
   * Suggested order of nodes for DOT output, to influence node placement.
   */
  nodeOrder?: NonEmptyReadonlyArray<NodeId>;
  /**
   * Invisible edges added by AI to enforce better layout
   */
  invisibleEdges?: NonEmptyReadonlyArray<AIEnforcementEdge>;
  /**
   * LLM reasoning for debugging/display
   */
  reasoning: string;
} //#endregion
//#endregion
//#region ../language-server/dist/_chunks/protocol.d.mts
/**
 * When server requests to open a likec4 preview panel
 * (available only in the editor).
 * (not the best place, but seems to be working)
 */
declare namespace DidRequestOpenViewNotification {
  type Params = {
    viewId: ViewId$1;
    projectId: ProjectId$1;
  };
  const type: NotificationType<Params>;
  type Type = typeof type;
}
/**
 * Request to fetch the computed model data
 * If LSP has multiple projects, the projectId is required.
 * otherwise throws an error.
 */
/**
 * Request to locate an element, relation, deployment or view.
 * If LSP has multiple projects, the projectId is required.
 */
declare namespace Locate {
  type Params =
  /**
   * Locate an element by its fqn
   */
  {
    element: Fqn$1;
    projectId?: string | undefined;
    property?: string;
  }
  /**
   * Locate a relation by its id
   */
  | {
    projectId?: string | undefined;
    relation: RelationId;
  }
  /**
   * Locate a deployment by its fqn
   */
  | {
    deployment: DeploymentFqn;
    projectId?: string | undefined;
    property?: string;
  }
  /**
   * Locate a step in a dynamic view by its astPath
   */
  | {
    view: ViewId$1;
    astPath: string;
    projectId?: string | undefined;
  }
  /**
   * Locate a view by its id
   */
  | {
    view: ViewId$1;
    projectId?: string | undefined;
  };
  type Res = Location | null;
  const req: RequestType<Params, Res, void>;
  type Req = typeof req;
}
/**
 * Request to change the view
 * If LSP has multiple projects, the projectId is required.
 */
declare namespace ChangeView {
  type Params = {
    viewId: ViewId$1;
    change: ViewChange;
    projectId?: string | undefined;
  };
  type Res = {
    success: true;
    location: Location | null;
  } | {
    success: false;
    location?: Location | null;
    error: string;
  };
  const req: RequestType<Params, Res, void>;
  type Req = typeof req;
}
/**
 * Request to fetch telemetry metrics
 */
//#endregion
//#region ../layouts/dist/_chunks/GraphvizLayoter.d.mts
//#region src/graphviz/types.d.ts
/**
 * Partially implements CancellationToken interface from vscode-jsonrpc
 */
type CancellationToken = {
  /**
   * Is `true` when the token has been cancelled, `false` otherwise.
   */
  readonly isCancellationRequested: boolean;
};
declare module 'ts-graphviz' {
  namespace GraphAttributeKey {
    interface $values extends $keywords<'likec4_viewId'> {}
  }
  namespace ClusterSubgraphAttributeKey {
    interface $values extends $keywords<'likec4_type' | 'likec4_path' | 'likec4_id' | 'likec4_level' | 'likec4_depth'> {}
  }
  namespace NodeAttributeKey {
    interface $values extends $keywords<'likec4_type' | 'likec4_path' | 'likec4_id' | 'likec4_project' | 'likec4_level'> {}
  }
  namespace EdgeAttributeKey {
    interface $values extends $keywords<'likec4_id' | 'likec4_project'> {}
  }
  namespace Attribute {
    interface $keys extends $keywords<'likec4_viewId' | 'likec4_type' | 'likec4_path' | 'likec4_id' | 'likec4_project' | 'likec4_level' | 'likec4_depth'> {}
    interface $types {
      likec4_viewId: string;
      likec4_type: 'folder' | 'file' | 'view';
      likec4_path: string;
      likec4_id: string;
      likec4_project: string;
      likec4_level: number;
      likec4_depth: number;
    }
  }
}
type DotSource = Tagged<string, 'DotSource'>; //#endregion
//#region src/graphviz/types-dot.d.ts
type GvNodeName = Tagged<string, 'GvNodeName'>;
type GvId = Tagged<number, 'GvId'>;
type Point = [x: number, y: number];
interface GraphvizJson {
  name: GvNodeName;
  directed: boolean;
  strict: boolean;
  _draw_: GraphvizJson.Draw[];
  bb: string;
  compound: string;
  fontname: string;
  fontsize: string;
  label: string;
  nodesep: string;
  outputorder: string;
  rankdir: string;
  ranksep: string;
  splines: string;
  xdotversion: string;
  _subgraph_cnt: number;
  objects?: GraphvizJson.GvObject[];
  edges?: GraphvizJson.Edge[];
}
declare namespace GraphvizJson {
  interface Draw {
    op: string;
    grad: string;
    color: string;
    points: Point[];
  }
  interface Draw2 {
    op: string;
    grad: string;
    color: string;
    points: Point[];
  }
  namespace DrawOps {
    type Style = {
      op: 'S';
      style: string;
    };
    type BSpline = {
      op: 'b' | 'B';
      points: Point[];
    };
    type Color = {
      op: 'c';
      grad: string;
      color: string;
    };
    type Polygon = {
      op: 'p' | 'P';
      points: Point[];
    };
  }
  type DrawOp = DrawOps.Style | DrawOps.BSpline | DrawOps.Color | DrawOps.Polygon;
  type LabelDrawOps = {
    op: 'F';
    size: number;
    face: string;
  } | {
    op: 'c';
    color: string;
  } | {
    op: 't';
    fontchar: number;
  } | {
    op: 'T';
    pt: Point;
    align: 'l' | 'r' | 'c';
    width: number;
    text: string;
  };
  type GvObject = GvNodeObject | GvSubgraph;
  interface GvSubgraph {
    bb: string;
    label?: string;
    compound: 'true';
    _ldraw_?: LabelDrawOps[];
    likec4_type?: 'folder' | 'file';
    likec4_path?: string;
    likec4_id?: Fqn$1;
    likec4_level?: number;
    likec4_depth?: number;
    _gvid: GvId;
    subgraphs?: GvId[];
    nodes?: GvId[];
    edges?: GvId[];
  }
  interface GvNodeObject {
    _draw_: Draw[];
    _ldraw_?: LabelDrawOps[];
    likec4_type?: 'folder' | 'file' | 'view';
    likec4_path?: string;
    likec4_id?: Fqn$1;
    likec4_level?: number;
    _gvid: GvId;
    height: string;
    pos: string;
    shape: 'rect';
    width: string;
    label?: string;
  }
  interface Draw3 {
    op: string;
    grad: string;
    color: string;
    points: Point[];
  }
  interface Hdraw {
    op: string;
    style: string;
    grad: string;
    color: string;
    points: Point[];
  }
  interface Edge {
    _gvid: GvId;
    tail: GvId;
    head: GvId;
    dir?: 'forward' | 'back' | 'both' | 'none';
    _draw_: DrawOp[];
    _hdraw_?: DrawOp[];
    _tdraw_?: DrawOp[];
    _ldraw_?: LabelDrawOps[];
    _tldraw_?: LabelDrawOps[];
    _hldraw_?: LabelDrawOps[];
    fontname: string;
    fontsize: string;
    likec4_id?: EdgeId$1;
    label: string;
    lp: string;
    nojustify?: 'true' | 'false';
    pos?: string;
  }
} //#endregion
//#region src/graphviz/GraphvizLayoter.d.ts
interface GraphvizPort extends Disposable {
  get name(): string;
  get concurrency(): number;
  unflatten(dot: DotSource): Promise<DotSource>;
  acyclic(dot: DotSource): Promise<DotSource>;
  layoutJson(dot: DotSource): Promise<string>;
  svg(dot: DotSource): Promise<string>;
  dispose(): void;
}
type LayoutTaskParams<A extends aux$1.Any = aux$1.Any> = {
  view: ComputedView<A>;
  styles: LikeC4Styles$1;
};
type LayoutResult<A extends aux$1.Any = aux$1.Any> = {
  dot: DotSource;
  diagram: DiagramView<A>;
};
declare class GraphvizLayouter implements Disposable {
  private graphviz;
  constructor(graphviz?: GraphvizPort);
  dispose(): void;
  [Symbol.dispose](): void;
  get graphvizPort(): GraphvizPort;
  changePort(graphviz: GraphvizPort): void;
  /**
   * Generates DOT source for the given view and styles.
   * If `hints` are provided, they will be used to influence the layout (e.g. by specifying node/edge order).
   * This method does not perform unflattening or any other post-processing on the DOT output, so it may be used for debugging or to generate DOT for external processing.
   */
  printToDot(params: LayoutTaskParams, hints?: AILayoutHints): DotSource;
  protected newScopedLogger(operation: string): any;
  dotToJson(dot: DotSource): Promise<GraphvizJson>;
  layout<A extends AnyAux>(params: LayoutTaskParams<A>): Promise<LayoutResult<A>>;
  aiLayout<A extends AnyAux>({
    view,
    styles
  }: LayoutTaskParams<A>, hints: AILayoutHints): Promise<LayoutResult<A>>;
  svg<A extends AnyAux>(params: LayoutTaskParams<A>): Promise<{
    svg: string;
    dot: DotSource;
  }>;
  dot<A extends AnyAux>(params: LayoutTaskParams<A>): Promise<DotSource>;
  layoutProjectsView(view: ComputedProjectsView): Promise<LayoutedProjectsView>;
} //#endregion
//#endregion
//#region ../layouts/dist/index.d.mts
//#region src/graphviz/QueueGraphvizLayoter.d.ts
declare class QueueGraphvizLayoter extends GraphvizLayouter {
  private queue;
  private isProcessingBatch;
  constructor(options?: {
    graphviz?: GraphvizPort;
    /**
     * Concurrency limit.
     * Minimum: `1`.
     * @default 2
     */
    concurrency?: number;
    /**
     * Per-operation timeout in milliseconds. Operations fulfill once `timeout` elapses if they haven't already.
     * @default 20_000
     */
    timeout?: number;
    /**
     * Whether or not a timeout is considered an exception.
     * @default true
     */
    throwOnTimeout?: boolean;
  });
  private runInQueue;
  changePort(graphvizPort: GraphvizPort): void;
  layout<A extends AnyAux>(params: LayoutTaskParams<A>): Promise<LayoutResult<A>>;
  layoutProjectsView(view: ComputedProjectsView): Promise<LayoutedProjectsView>;
  batchLayout<A extends AnyAux>(params: {
    batch: LayoutTaskParams<A>[];
    cancelToken?: CancellationToken | undefined;
    onSuccess?: (task: LayoutTaskParams<A>, result: LayoutResult<A>) => void;
    onError?: (task: LayoutTaskParams<A>, error: unknown) => void;
  }): Promise<LayoutResult<A>[]>;
  /**
   * Custom backpressure
   * (basically allow same amount of tasks to be in queue as concurrency)
   */
  private waitForQueueToShrink;
  dispose(): void;
} //#endregion
//#region src/graphviz/wasm/GraphvizWasmAdapter.d.ts
//#endregion
//#region ../language-server/dist/_chunks/module.d.mts
//#region src/documentation/documentation-provider.d.ts
/**
 * Provides documentation for LikeC4 AST nodes, extending JSDoc parsing
 * with specialized formatting for deployment nodes, deployed instances, and elements.
 */
declare class LikeC4DocumentationProvider extends JSDocDocumentationProvider {
  private parser;
  private locator;
  /**
   * Creates a new documentation provider.
   * @param services - The LikeC4 language services.
   */
  constructor(services: LikeC4Services);
  /**
   * Returns documentation for the given AST node (deployment nodes, deployed instances, elements, or JSDoc fallback).
   * @param node - The AST node to document.
   * @returns Formatted documentation string, or undefined if none.
   */
  getDocumentation(node: AstNode): string | undefined;
} //#endregion
//#region src/workspace/ProjectsManager.d.ts
type NormalizedUri = Tagged<string, 'NormalizedUri'>;
type DocOrUri = LangiumDocument | string | URI;
/**
 * A tagged string that represents a project folder URI (with trailing slash).
 * Used in `startsWith` checks to determine if a document belongs to a project.
 */
type ProjectFolder = Tagged<string, 'ProjectFolder'>;
declare function ProjectFolder(folder: URI | string): ProjectFolder;
interface Project {
  id: ProjectId;
  folderUri: URI;
  config: LikeC4ProjectConfig;
}
interface ProjectData extends Project {
  id: ProjectId;
  folder: ProjectFolder;
  config: LikeC4ProjectConfig;
  configUri: URI;
  folderUri: URI;
  exclude?: {
    (test: string): boolean;
  };
  /**
   * Resolved include paths with both URI and folder string representations.
   * These are additional directories that are part of this project.
   */
  includePaths?: NonEmptyArray$1<{
    uri: URI;
    folder: ProjectFolder;
  }>;
  /**
   * Normalized include configuration (paths, maxDepth, fileThreshold).
   */
  includeConfig: IncludeConfig;
}
type RegisterProjectOptions = {
  config: LikeC4ProjectConfig | LikeC4ProjectConfigInput;
} & ({
  configUri: URI | string;
} | {
  folderUri: URI | string;
});
declare class ProjectsManager {
  #private;
  protected services: LikeC4SharedServices;
  /**
   * The global project ID used for all documents
   * that are not part of a specific project.
   */
  static readonly DefaultProjectId: ProjectId;
  constructor(services: LikeC4SharedServices);
  /**
   * Checks if a document is excluded by workspace-level patterns.
   * These patterns come from VS Code settings and take precedence over project-level excludes.
   */
  isExcludedByWorkspace(uri: NormalizedUri | URI): boolean;
  /**
   * Updates the workspace-level exclude patterns from VS Code settings.
   * Called during initial server startup; dynamic changes restart the server.
   */
  setWorkspaceExcludePatterns(patterns: string[] | undefined): void;
  /**
   * Returns:
   *  - configured default project ID if set
   *  - the default project ID if there are no projects.
   *  - the ID of the only project
   *  - undefined if there are multiple projects.
   */
  get defaultProjectId(): ProjectId | undefined;
  set defaultProjectId(id: string | ProjectId | undefined);
  get default(): ProjectData;
  get all(): NonEmptyReadonlyArray$1<ProjectId>;
  getProject(arg: ProjectId | LangiumDocument): ProjectData;
  /**
   * Returns all projects that overlap with the specified folder (is parent or child)
   */
  findOverlaped(folder: URI | string): ReadonlyArray<ProjectData>;
  /**
   * Validates and ensures the project ID.
   * If no project ID is specified, returns default project ID
   * If there are multiple projects and default project is not set, throws an error
   */
  ensureProjectId(projectId?: ProjectId | undefined): ProjectId;
  /**
   * Validates and ensures the project data.
   * If projectId is not specified, returns default project
   *
   * If there are multiple projects and default project is not set, throws an error
   *
   * @see ensureProjectId - to validate project ID only
   */
  ensureProject(projectId?: ProjectId | undefined): ProjectData;
  hasMultipleProjects(): boolean;
  /**
   * Checks if given document (or URI) must be excluded from processing.
   */
  isExcluded(document: DocOrUri): boolean;
  /**
   * Checks if given document (or URI) must be excluded in the context of the project.
   */
  isExcluded(projectId: ProjectId, document: DocOrUri): boolean;
  /**
   * Checks if the specified document is included by the project:
   * - if the document belongs to the project and is not excluded
   * - if the document is included by the project
   */
  isIncluded(projectId: ProjectId, document: LangiumDocument | URI | string): boolean;
  /**
   * Registers likec4 project by config file.
   */
  registerConfigFile(configUri: URI, cancelToken?: CancellationToken$1): Promise<ProjectData>;
  /**
   * Registers (or reloads) likec4 project by config file or config object.
   * If there is some project registered at same folder, it will be reloaded.
   */
  registerProject(opts: RegisterProjectOptions, cancelToken?: CancellationToken$1): Promise<ProjectData>;
  /**
   * Determines which project the given document belongs to.
   * If the document does not belong to any project, returns the default project ID.
   */
  ownerProjectId(document: LangiumDocument | URI | string): ProjectId;
  /**
   * Returns path to the document relative to the project folder.
   * If the document does not belong to any project, returns the document URI as string.
   */
  relativePath(document: LangiumDocument | URI | string): string;
  /**
   * Returns true if the manager is currently initializing or reloading projects.
   * This is used to prevent duplicate reload operations.
   */
  protected get isInitiatingOrReloading(): boolean;
  reloadProjects(cancelToken?: CancellationToken$1): Promise<void>;
  protected _reloadProjects(cancelToken?: CancellationToken$1): Promise<void>;
  protected uniqueProjectId(name: string): ProjectId;
  protected resetCaches(): void;
  rebuildProject(projectId: ProjectId, cancelToken?: CancellationToken$1): Promise<void>;
  /**
   * Returns all include paths from all projects.
   * Used by WorkspaceManager to scan additional directories for C4 files.
   */
  getAllIncludePaths(): Array<{
    projectId: ProjectId;
    includePath: URI;
    includeConfig: IncludeConfig;
  }>;
  /**
   * Register a listener to be called when the projects configuration has changed.
   * @returns A disposable that can be used to unregister the callback.
   */
  onProjectsUpdate(callback: () => void): Disposable$1;
  private getWorkspaceFolder;
  private notifyListeners;
  private updateIncludesExcludes;
  private warnIfConfigOverride;
} //#endregion
//#region src/filesystem/types.d.ts
interface FileNode extends FileSystemNode {
  readonly isFile: true;
  readonly isDirectory: false;
}
interface FileSystemProvider$1 extends FileSystemProvider {
  /**
   * Scans the project files for the given URI.
   * @returns The list of file system entries that are contained within the specified directory.
   */
  scanProjectFiles(folderUri: URI): Promise<FileNode[]>;
  /**
   * Loads the project config from the given file.
   * @returns The project config.
   * @throws Error if the file does not exist or is not a valid project config.
   */
  loadProjectConfig(filepath: URI): Promise<LikeC4ProjectConfig>;
  /**
   * Reads the directory and returns LikeC4 files.
   *
   * @param options.recursive If true, recursively reads the directory,
   * @param options.maxDepth Maximum depth to traverse when recursive is true (default: Infinity)
   */
  readDirectory(uri: URI, options?: {
    recursive?: boolean;
    maxDepth?: number;
  }): Promise<FileNode[]>;
  /**
   * Finds all files in the given directory, matching the given filter.
   */
  scanDirectory(directory: URI, filter: (filepath: string, isDirectory: boolean) => boolean): Promise<FileNode[]>;
  /**
   * Writes the content to the file system.
   * Used by manual layouts.
   */
  writeFile(uri: URI, content: string): Promise<void>;
  /**
   * Deletes the file from the file system.
   * Used by manual layouts.
   * @return true if the file was deleted, false if the file did not exist.
   */
  deleteFile(uri: URI): Promise<boolean>;
}
interface FileSystemWatcher extends AsyncDisposable {
  /**
   * Watches a folder for changes and triggers a reload of the documents and projects.
   */
  watch(folder: string): void;
}
type ManualLayoutsSnapshot = {
  hash: string;
  views: Record<ViewId, LayoutedView>;
};
type ManualLayoutUpdateEvent = {
  updated: URI;
  projectId: ProjectId;
  viewId: ViewId;
} | {
  removed: URI;
  projectId: ProjectId;
  /**
   * Missing if triggered by FS event (file was deleted)
   */
  viewId?: ViewId;
};
type ManualLayoutUpdateListener = (event: ManualLayoutUpdateEvent) => void;
interface LikeC4ManualLayouts {
  /**
   * Reads a single layouted view from the file system by its URI.
   * Used by the language server to get the current layout state.
   */
  readSnapshot(uri: URI): Promise<LayoutedView | null>;
  read(project: Project): Promise<ManualLayoutsSnapshot | null>;
  write(project: Project, layouted: LayoutedView): Promise<Location>;
  remove(project: Project, view: ViewId): Promise<Location | null>;
  clearCaches(): void;
  /**
   * Registers a listener for manual layout updates.
   * The listener will be called when a manual layout is created, updated, or deleted.
   */
  onManualLayoutUpdate(listener: ManualLayoutUpdateListener): Disposable$1;
  /**
   * Handles file system updates for manual layouts.
   * Used by the file system watcher to notify the manual layouts module of changes.
   * @param event The file system event
   */
  handleFileSystemUpdate(event: {
    update: URI;
    delete?: never;
  } | {
    delete: URI;
    update?: never;
  }): Promise<void>;
} //#endregion
//#region src/filesystem/noop.d.ts
//#endregion
//#region src/formatting/LikeC4Formatter.d.ts
type QuoteStyle = 'single' | 'double' | 'ignore' | 'auto';
interface LikeC4FormatterOptions {
  quoteStyle: QuoteStyle;
}
type ExtendedFormattingCommandType = 'normalizeQuotes';
interface ExtendedFormattingCommand {
  type: ExtendedFormattingCommandType;
  region: FormattingRegion;
}
declare class LikeC4Formatter extends AbstractFormatter {
  protected options: LikeC4FormatterOptions;
  extendedFormattingCommands: ExtendedFormattingCommand[];
  constructor(services: LikeC4Services);
  protected doDocumentFormat(document: LangiumDocument, options: FormattingOptions, range?: Range): TextEdit[];
  protected format(node: AstNode): void;
  protected formatTags(node: AstNode): void;
  protected formatDeploymentRelation(node: AstNode): void;
  protected formatExtendDeployment(node: AstNode): void;
  protected formatRelation(node: AstNode): void;
  protected removeIndentFromTopLevelStatements(node: AstNode): void;
  protected indentContentInBraces(node: AstNode): void;
  protected appendKeywordsWithSpace(node: AstNode): void;
  protected formatView(node: AstNode): void;
  protected formatLeafProperty(node: AstNode): void;
  protected formatLinkProperty(node: AstNode): void;
  protected formatNavigateToProperty(node: AstNode): void;
  protected formatAutolayoutProperty(node: AstNode): void;
  protected formatMetadataProperty(node: AstNode): void;
  protected formatElementDeclaration(node: AstNode): void;
  protected formatExtendElement(node: AstNode): void;
  protected formatGlobals(node: AstNode): void;
  protected formatImports(node: AstNode): void;
  protected formatSpecificationRule(node: AstNode): void;
  protected formatWithPredicate(node: AstNode): void;
  protected formatDeploymentNodeDeclaration(node: AstNode): void;
  protected formatDeployedInstance(node: AstNode): void;
  protected formatViewRuleGlobalStyle(node: AstNode): void;
  protected formatViewRuleGlobalPredicate(node: AstNode): void;
  protected formatViewRuleGroup(node: AstNode): void;
  protected formatViewRuleStyle(node: AstNode): void;
  protected formatWhereExpression(node: AstNode): void;
  protected formatWhereRelationExpression(node: AstNode): void;
  protected formatWhereElementExpression(node: AstNode): void;
  protected formatIncludeExcludeExpressions(node: AstNode): void;
  protected formatRelationExpression(node: AstNode): void;
  private findPredicateExpressionRoot;
  private on;
  private doExtendedFormatting;
  protected normalizeQuotes(node: AstNode): void;
  private quotesNormalizerFactory;
  private escapeQuotesInternalQuotes;
  private getAutoQuoteStyle;
  private onConfigurationUpdate;
} //#endregion
//#region src/generated/ast.d.ts
type AnyProperty = DynamicViewProperty | ElementProperty | NavigateToProperty | NotationProperty | NotesProperty | RelationProperty | RelationshipStyleProperty | StringProperty | StyleProperty | ViewProperty;
declare const AnyProperty = "AnyProperty";
type ArrowType = 'crow' | 'diamond' | 'dot' | 'none' | 'normal' | 'odiamond' | 'odot' | 'onormal' | 'open' | 'vee';
type BorderStyleValue = 'none' | LineOptions;
type ColorLiteral$1 = HexColor | RGBAColor;
declare const ColorLiteral$1 = "ColorLiteral";
type CustomColorId = 'element' | 'model' | ArrowType | ElementShape | LineOptions | Participant | string;
type DeploymentElement = DeployedInstance | DeploymentNode;
declare const DeploymentElement = "DeploymentElement";
type DeploymentNodeOrElementKind = DeploymentNodeKind | ElementKind;
declare const DeploymentNodeOrElementKind = "DeploymentNodeOrElementKind";
type DeploymentViewRule = DeploymentViewRulePredicate | DeploymentViewRuleStyle | ViewRuleAncestors | ViewRuleAutoLayout;
declare const DeploymentViewRule = "DeploymentViewRule";
type DynamicViewDisplayVariantValue = 'diagram' | 'sequence';
type DynamicViewProperty = DynamicViewDisplayVariantProperty | ViewProperty;
declare const DynamicViewProperty = "DynamicViewProperty";
type DynamicViewRule = DynamicViewGlobalPredicateRef | DynamicViewIncludePredicate | ViewRuleAutoLayout | ViewRuleStyleOrGlobalRef;
declare const DynamicViewRule = "DynamicViewRule";
type DynamicViewStep = DynamicStepChain | DynamicStepSingle;
declare const DynamicViewStep = "DynamicViewStep";
type ElementProperty = ElementStringProperty | ElementStyleProperty | IconProperty | LinkProperty | MetadataProperty;
declare const ElementProperty = "ElementProperty";
type ElementShape = 'browser' | 'bucket' | 'component' | 'cylinder' | 'document' | 'mobile' | 'person' | 'queue' | 'rectangle' | 'storage';
type ExpressionV2 = FqnExprOrWith | RelationExprOrWith;
declare const ExpressionV2 = "ExpressionV2";
type ExtendElementProperty = LinkProperty | MetadataProperty;
declare const ExtendElementProperty = "ExtendElementProperty";
type ExtendRelationProperty = LinkProperty | MetadataProperty;
declare const ExtendRelationProperty = "ExtendRelationProperty";
type FqnExpr$2 = ElementKindExpression | ElementTagExpression | FqnRefExpr | WildcardExpression;
declare const FqnExpr$2 = "FqnExpr";
type FqnExprOrWhere = FqnExpr$2 | FqnExprWhere;
declare const FqnExprOrWhere = "FqnExprOrWhere";
type FqnExprOrWith = FqnExprOrWhere | FqnExprWith;
declare const FqnExprOrWith = "FqnExprOrWith";
type FqnReferenceable = Element | ExtendDeployment | ExtendElement | Referenceable;
declare const FqnReferenceable = "FqnReferenceable";
type IconId = string;
type IconPositionValue = 'bottom' | 'left' | 'right' | 'top';
type Id = 'deployment' | 'element' | 'group' | 'instance' | 'model' | 'node' | 'relationship' | ArrowType | DynamicViewDisplayVariantValue | ElementShape | IconPositionValue | LineOptions | Participant | RankValue | SizeValue | ThemeColor | string;
type LikeC4View = DeploymentView | DynamicView | ElementView;
declare const LikeC4View = "LikeC4View";
type LineOptions = 'dashed' | 'dotted' | 'solid';
type MetadataFilterValue = boolean | string;
type MetadataProperty = MetadataBody;
declare const MetadataProperty = "MetadataProperty";
type MetadataValue = MarkdownOrString | MetadataArray;
declare const MetadataValue = "MetadataValue";
type ModelReferenceable = Element | Imported;
declare const ModelReferenceable = "ModelReferenceable";
type Participant = 'source' | 'target';
type RankValue = 'max' | 'min' | 'same' | 'sink' | 'source';
type Referenceable = DeployedInstance | DeploymentNode | Element | Imported;
declare const Referenceable = "Referenceable";
type RelationExpr$1 = DirectedRelationExpr | InOutRelationExpr | IncomingRelationExpr | OutgoingRelationExpr;
declare const RelationExpr$1 = "RelationExpr";
type RelationExprOrWhere = RelationExpr$1 | RelationExprWhere;
declare const RelationExprOrWhere = "RelationExprOrWhere";
type RelationExprOrWith = RelationExprOrWhere | RelationExprWith;
declare const RelationExprOrWith = "RelationExprOrWith";
type RelationProperty = LinkProperty | MetadataProperty | RelationNavigateToProperty | RelationStringProperty | RelationStyleProperty;
declare const RelationProperty = "RelationProperty";
type RelationshipStyleProperty = ArrowProperty | ColorProperty | LineProperty;
declare const RelationshipStyleProperty = "RelationshipStyleProperty";
type SizeProperty = IconSizeProperty | PaddingSizeProperty | ShapeSizeProperty | TextSizeProperty;
declare const SizeProperty = "SizeProperty";
type SizeValue = 'large' | 'lg' | 'md' | 'medium' | 'sm' | 'small' | 'xl' | 'xlarge' | 'xs' | 'xsmall';
type StringProperty = ElementStringProperty | MetadataAttribute | NotationProperty | NotesProperty | RelationStringProperty | SpecificationElementStringProperty | SpecificationRelationshipStringProperty | ViewStringProperty;
declare const StringProperty = "StringProperty";
type StyleProperty = BorderProperty | ColorProperty | IconColorProperty | IconPositionProperty | IconProperty | IconSizeProperty | MultipleProperty | OpacityProperty | PaddingSizeProperty | ShapeProperty | ShapeSizeProperty | TextSizeProperty;
declare const StyleProperty = "StyleProperty";
type ThemeColor = 'amber' | 'blue' | 'gray' | 'green' | 'indigo' | 'muted' | 'primary' | 'red' | 'secondary' | 'sky' | 'slate';
type Uri = string;
type ViewLayoutDirection = 'BottomTop' | 'LeftRight' | 'RightLeft' | 'TopBottom';
type ViewProperty = LinkProperty | ViewStringProperty;
declare const ViewProperty = "ViewProperty";
type ViewRule = ViewRuleAutoLayout | ViewRuleGlobalPredicateRef | ViewRuleGroup | ViewRulePredicate | ViewRuleRank | ViewRuleStyleOrGlobalRef;
declare const ViewRule = "ViewRule";
type ViewRuleStyleOrGlobalRef = ViewRuleGlobalStyle | ViewRuleStyle;
declare const ViewRuleStyleOrGlobalRef = "ViewRuleStyleOrGlobalRef";
type WhereElement = WhereElementKind | WhereElementMetadata | WhereElementTag;
declare const WhereElement = "WhereElement";
type WhereElementExpression = WhereBinaryExpression | WhereElement | WhereElementNegation;
declare const WhereElementExpression = "WhereElementExpression";
type WhereExpression = WhereElementExpression | WhereRelationExpression;
declare const WhereExpression = "WhereExpression";
type WhereKindEqual = WhereElementKind | WhereRelationKind | WhereRelationParticipantKind;
declare const WhereKindEqual = "WhereKindEqual";
type WhereMetadataEqual = WhereElementMetadata | WhereRelationMetadata | WhereRelationParticipantMetadata;
declare const WhereMetadataEqual = "WhereMetadataEqual";
type WhereRelation = WhereRelationKind | WhereRelationMetadata | WhereRelationParticipantKind | WhereRelationParticipantMetadata | WhereRelationParticipantTag | WhereRelationTag;
declare const WhereRelation = "WhereRelation";
type WhereRelationExpression = WhereBinaryExpression | WhereRelation | WhereRelationNegation;
declare const WhereRelationExpression = "WhereRelationExpression";
type WhereTagEqual = WhereElementTag | WhereRelationParticipantTag | WhereRelationTag;
declare const WhereTagEqual = "WhereTagEqual";
interface AbstractDynamicStep extends AstNode {
  readonly $container: DynamicStepChain | DynamicViewBody | DynamicViewParallelSteps;
  readonly $type: 'AbstractDynamicStep' | 'DynamicStepChain' | 'DynamicStepSingle';
  custom?: CustomRelationProperties;
  dotKind?: RelationKindDotRef;
  kind?: Reference<RelationshipKind>;
  target: ElementRef;
  title?: string;
}
declare const AbstractDynamicStep = "AbstractDynamicStep";
interface ArrowProperty extends AstNode {
  readonly $container: CustomRelationProperties | RelationStyleProperty | SpecificationRelationshipKind;
  readonly $type: 'ArrowProperty';
  key: 'head' | 'tail';
  value: ArrowType;
}
declare const ArrowProperty = "ArrowProperty";
interface BorderProperty extends AstNode {
  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 | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | RelationStyleProperty | SpecificationRelationshipKind | ViewRuleGroup | ViewRuleStyle;
  readonly $type: 'ColorProperty';
  customColor?: Reference<CustomColor>;
  key: 'color';
  themeColor?: ThemeColor;
}
declare const ColorProperty = "ColorProperty";
interface CustomColor extends AstNode {
  readonly $container: SpecificationColor;
  readonly $type: 'CustomColor';
  name: CustomColorId;
}
declare const CustomColor = "CustomColor";
interface CustomElementProperties extends AstNode {
  readonly $container: FqnExprWith;
  readonly $type: 'CustomElementProperties';
  props: Array<ElementStringProperty | NavigateToProperty | NotationProperty | NotesProperty | StyleProperty>;
}
declare const CustomElementProperties = "CustomElementProperties";
interface CustomRelationProperties extends AstNode {
  readonly $container: AbstractDynamicStep | RelationExprWith;
  readonly $type: 'CustomRelationProperties';
  props: Array<MultipleProperty | NotationProperty | NotesProperty | RelationNavigateToProperty | RelationStringProperty | RelationshipStyleProperty>;
}
declare const CustomRelationProperties = "CustomRelationProperties";
interface DeployedInstance extends AstNode {
  readonly $container: DeploymentNodeBody | ExtendDeploymentBody;
  readonly $type: 'DeployedInstance';
  body?: DeployedInstanceBody;
  name?: Id;
  summary?: string;
  target: ElementRef;
  title?: string;
}
declare const DeployedInstance = "DeployedInstance";
interface DeployedInstanceBody extends AstNode {
  readonly $container: DeployedInstance;
  readonly $type: 'DeployedInstanceBody';
  elements: Array<DeploymentRelation>;
  props: Array<ElementProperty>;
  tags?: Tags;
}
declare const DeployedInstanceBody = "DeployedInstanceBody";
interface DeploymentNode extends AstNode {
  readonly $container: DeploymentNodeBody | ExtendDeploymentBody | ModelDeployments;
  readonly $type: 'DeploymentNode';
  body?: DeploymentNodeBody;
  kind: Reference<DeploymentNodeKind>;
  name: Id;
  summary?: string;
  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 DeploymentRelation extends AstNode {
  readonly $container: DeployedInstanceBody | DeploymentNodeBody | ExtendDeploymentBody | ModelDeployments;
  readonly $type: 'DeploymentRelation';
  body?: DeploymentRelationBody;
  description?: string;
  dotKind?: RelationKindDotRef;
  kind?: Reference<RelationshipKind>;
  source?: FqnRef$2;
  tags?: Tags;
  target: FqnRef$2;
  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: Expressions;
  isInclude: boolean;
}
declare const DeploymentViewRulePredicate = "DeploymentViewRulePredicate";
interface DeploymentViewRuleStyle extends AstNode {
  readonly $container: DeploymentViewBody;
  readonly $type: 'DeploymentViewRuleStyle';
  props: Array<NotationProperty | StyleProperty>;
  targets: FqnExpressions;
}
declare const DeploymentViewRuleStyle = "DeploymentViewRuleStyle";
interface DirectedRelationExpr extends AstNode {
  readonly $container: Expressions | RelationExprWhere | RelationExprWith;
  readonly $type: 'DirectedRelationExpr';
  source: OutgoingRelationExpr;
  target: FqnExpr$2;
}
declare const DirectedRelationExpr = "DirectedRelationExpr";
interface DynamicView extends AstNode {
  readonly $container: ModelViews;
  readonly $type: 'DynamicView';
  body?: DynamicViewBody;
  name: Id;
}
declare const DynamicView = "DynamicView";
interface DynamicViewBody extends AstNode {
  readonly $container: DynamicView;
  readonly $type: 'DynamicViewBody';
  props: Array<DynamicViewProperty>;
  rules: Array<DynamicViewRule>;
  steps: Array<DynamicViewParallelSteps | DynamicViewStep>;
  tags?: Tags;
}
declare const DynamicViewBody = "DynamicViewBody";
interface DynamicViewDisplayVariantProperty extends AstNode {
  readonly $container: DynamicViewBody;
  readonly $type: 'DynamicViewDisplayVariantProperty';
  key: 'variant';
  value: DynamicViewDisplayVariantValue;
}
declare const DynamicViewDisplayVariantProperty = "DynamicViewDisplayVariantProperty";
interface DynamicViewGlobalPredicateRef extends AstNode {
  readonly $container: DynamicViewBody;
  readonly $type: 'DynamicViewGlobalPredicateRef';
  predicate: Reference<GlobalDynamicPredicateGroup>;
}
declare const DynamicViewGlobalPredicateRef = "DynamicViewGlobalPredicateRef";
interface DynamicViewIncludePredicate extends AstNode {
  readonly $container: DynamicViewBody | GlobalDynamicPredicateGroup;
  readonly $type: 'DynamicViewIncludePredicate';
  exprs: Expressions;
}
declare const DynamicViewIncludePredicate = "DynamicViewIncludePredicate";
interface DynamicViewParallelSteps extends AstNode {
  readonly $container: DynamicViewBody;
  readonly $type: 'DynamicViewParallelSteps';
  steps: Array<DynamicViewStep>;
}
declare const DynamicViewParallelSteps = "DynamicViewParallelSteps";
interface DynamicViewRef extends AstNode {
  readonly $container: RelationNavigateToProperty;
  readonly $type: 'DynamicViewRef';
  view: Reference<DynamicView>;
}
declare const DynamicViewRef = "DynamicViewRef";
interface Element extends AstNode {
  readonly $container: ElementBody | ExtendElementBody | Model;
  readonly $type: 'Element';
  body?: ElementBody;
  kind: Reference<ElementKind>;
  name: Id;
  props: Array<string>;
}
declare const Element = "Element";
interface ElementBody extends AstNode {
  readonly $container: Element;
  readonly $type: 'ElementBody';
  elements: Array<Element | Relation>;
  props: Array<ElementProperty>;
  tags?: Tags;
}
declare const ElementBody = "ElementBody";
interface ElementKind extends AstNode {
  readonly $container: SpecificationElementKind;
  readonly $type: 'ElementKind';
  name: Id;
}
declare const ElementKind = "ElementKind";
interface ElementKindExpression extends AstNode {
  readonly $container: DirectedRelationExpr | Expressions | FqnExprWhere | FqnExprWith | FqnExpressions | IncomingRelationExpr | OutgoingRelationExpr;
  readonly $type: 'ElementKindExpression';
  isEqual: boolean;
  kind: Reference<ElementKind>;
}
declare const ElementKindExpression = "ElementKindExpression";
interface ElementRef extends AstNode {
  readonly $container: AbstractDynamicStep | DeployedInstance | DynamicStepSingle | ElementView;
  readonly $type: 'ElementRef';
  modelElement: FqnRef$2;
}
declare const ElementRef = "ElementRef";
interface ElementStringProperty extends AstNode {
  readonly $container: CustomElementProperties | DeployedInstanceBody | DeploymentNodeBody | ElementBody;
  readonly $type: 'ElementStringProperty';
  key: 'description' | 'summary' | 'technology' | 'title';
  value: MarkdownOrString;
}
declare const ElementStringProperty = "ElementStringProperty";
interface ElementStyleProperty extends AstNode {
  readonly $container: DeployedInstanceBody | DeploymentNodeBody | ElementBody | SpecificationDeploymentNodeKind | SpecificationElementKind;
  readonly $type: 'ElementStyleProperty';
  key: 'style';
  props: Array<StyleProperty>;
}
declare const ElementStyleProperty = "ElementStyleProperty";
interface ElementTagExpression extends AstNode {
  readonly $container: DirectedRelationExpr | Expressions | FqnExprWhere | FqnExprWith | FqnExpressions | IncomingRelationExpr | OutgoingRelationExpr;
  readonly $type: 'ElementTagExpression';
  isEqual: boolean;
  tag: TagRef;
}
declare const ElementTagExpression = "ElementTagExpression";
interface ElementView extends AstNode {
  readonly $container: ModelViews;
  readonly $type: 'ElementView';
  body?: ElementViewBody;
  extends?: ElementViewRef;
  name?: Id;
  viewOf?: ElementRef;
}
declare const ElementView = "ElementView";
interface ElementViewBody extends AstNode {
  readonly $container: ElementView;
  readonly $type: 'ElementViewBody';
  props: Array<ViewProperty>;
  rules: Array<ViewRule>;
  tags?: Tags;
}
declare const ElementViewBody = "ElementViewBody";
interface ElementViewRef extends AstNode {
  readonly $container: ElementView;
  readonly $type: 'ElementViewRef';
  view: Reference<ElementView>;
}
declare const ElementViewRef = "ElementViewRef";
interface Expressions extends AstNode {
  readonly $container: DeploymentViewRulePredicate | DynamicViewIncludePredicate | Expressions | ViewRulePredicate;
  readonly $type: 'Expressions';
  prev?: Expressions;
  value: ExpressionV2;
}
declare const Expressions = "Expressions";
interface ExtendDeployment extends AstNode {
  readonly $container: ModelDeployments;
  readonly $type: 'ExtendDeployment';
  body: ExtendDeploymentBody;
  deploymentNode: StrictFqnRef;
}
declare const ExtendDeployment = "ExtendDeployment";
interface ExtendDeploymentBody extends AstNode {
  readonly $container: ExtendDeployment;
  readonly $type: 'ExtendDeploymentBody';
  elements: Array<DeployedInstance | DeploymentNode | DeploymentRelation>;
  props: Array<ExtendElementProperty>;
  tags?: Tags;
}
declare const ExtendDeploymentBody = "ExtendDeploymentBody";
interface ExtendElement extends AstNode {
  readonly $container: Model;
  readonly $type: 'ExtendElement';
  body: ExtendElementBody;
  element: StrictFqnElementRef;
}
declare const ExtendElement = "ExtendElement";
interface ExtendElementBody extends AstNode {
  readonly $container: ExtendElement;
  readonly $type: 'ExtendElementBody';
  elements: Array<Element | Relation>;
  props: Array<ExtendElementProperty>;
  tags?: Tags;
}
declare const ExtendElementBody = "ExtendElementBody";
interface ExtendRelation extends AstNode {
  readonly $container: Model;
  readonly $type: 'ExtendRelation';
  body: ExtendRelationBody;
  dotKind?: RelationKindDotRef;
  kind?: Reference<RelationshipKind>;
  source: FqnRef$2;
  target: FqnRef$2;
  title?: string;
}
declare const ExtendRelation = "ExtendRelation";
interface ExtendRelationBody extends AstNode {
  readonly $container: ExtendRelation;
  readonly $type: 'ExtendRelationBody';
  props: Array<ExtendRelationProperty>;
  tags?: Tags;
}
declare const ExtendRelationBody = "ExtendRelationBody";
interface FqnExpressions extends AstNode {
  readonly $container: DeploymentViewRuleStyle | FqnExpressions | GlobalStyle | ViewRuleRank | ViewRuleStyle;
  readonly $type: 'FqnExpressions';
  prev?: FqnExpressions;
  value: FqnExpr$2;
}
declare const FqnExpressions = "FqnExpressions";
interface FqnExprWhere extends AstNode {
  readonly $container: Expressions | FqnExprWith;
  readonly $type: 'FqnExprWhere';
  subject: FqnExpr$2;
  where?: WhereElementExpression;
}
declare const FqnExprWhere = "FqnExprWhere";
interface FqnExprWith extends AstNode {
  readonly $container: Expressions;
  readonly $type: 'FqnExprWith';
  custom?: CustomElementProperties;
  subject: FqnExprOrWhere;
}
declare const FqnExprWith = "FqnExprWith";
interface FqnRef$2 extends AstNode {
  readonly $container: DeploymentRelation | ElementRef | ExtendRelation | FqnRef$2 | FqnRefExpr | Relation;
  readonly $type: 'FqnRef';
  parent?: FqnRef$2;
  value: Reference<Referenceable>;
}
declare const FqnRef$2 = "FqnRef";
interface FqnRefExpr extends AstNode {
  readonly $container: DirectedRelationExpr | Expressions | FqnExprWhere | FqnExprWith | FqnExpressions | IncomingRelationExpr | OutgoingRelationExpr;
  readonly $type: 'FqnRefExpr';
  ref: FqnRef$2;
  selector?: string;
}
declare const FqnRefExpr = "FqnRefExpr";
interface GlobalDynamicPredicateGroup extends AstNode {
  readonly $container: Globals;
  readonly $type: 'GlobalDynamicPredicateGroup';
  name: string;
  predicates: Array<DynamicViewIncludePredicate>;
}
declare const GlobalDynamicPredicateGroup = "GlobalDynamicPredicateGroup";
interface GlobalPredicateGroup extends AstNode {
  readonly $container: Globals;
  readonly $type: 'GlobalPredicateGroup';
  name: string;
  predicates: Array<ViewRulePredicate>;
}
declare const GlobalPredicateGroup = "GlobalPredicateGroup";
interface Globals extends AstNode {
  readonly $container: LikeC4Grammar;
  readonly $type: 'Globals';
  name: 'global';
  predicates: Array<GlobalDynamicPredicateGroup | GlobalPredicateGroup>;
  styles: Array<GlobalStyle | GlobalStyleGroup>;
}
declare const Globals = "Globals";
interface GlobalStyle extends AstNode {
  readonly $container: Globals;
  readonly $type: 'GlobalStyle';
  id: GlobalStyleId;
  props: Array<NotationProperty | StyleProperty>;
  targets: FqnExpressions;
}
declare const GlobalStyle = "GlobalStyle";
interface GlobalStyleGroup extends AstNode {
  readonly $container: Globals;
  readonly $type: 'GlobalStyleGroup';
  id: GlobalStyleId;
  styles: Array<ViewRuleStyle>;
}
declare const GlobalStyleGroup = "GlobalStyleGroup";
interface GlobalStyleId extends AstNode {
  readonly $container: GlobalStyle | GlobalStyleGroup;
  readonly $type: 'GlobalStyleId';
  name: string;
}
declare const GlobalStyleId = "GlobalStyleId";
interface HexColor extends AstNode {
  readonly $container: SpecificationColor | SpecificationTag;
  readonly $type: 'HexColor';
  hex: number | string;
}
declare const HexColor = "HexColor";
interface IconColorProperty extends AstNode {
  readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
  readonly $type: 'IconColorProperty';
  customColor?: Reference<CustomColor>;
  key: 'iconColor';
  themeColor?: ThemeColor;
}
declare const IconColorProperty = "IconColorProperty";
interface IconPositionProperty extends AstNode {
  readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
  readonly $type: 'IconPositionProperty';
  key: 'iconPosition';
  value: IconPositionValue;
}
declare const IconPositionProperty = "IconPositionProperty";
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;
}
declare const IconProperty = "IconProperty";
interface IconSizeProperty extends AstNode {
  readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
  readonly $type: 'IconSizeProperty';
  key: 'iconSize';
  value: SizeValue;
}
declare const IconSizeProperty = "IconSizeProperty";
interface Imported extends AstNode {
  readonly $container: Imported | ImportsFromPoject;
  readonly $type: 'Imported';
  imported: Reference<Element>;
  prev?: Imported;
}
declare const Imported = "Imported";
interface ImportsFromPoject extends AstNode {
  readonly $container: LikeC4Grammar;
  readonly $type: 'ImportsFromPoject';
  imports: Imported;
  project: string;
}
declare const ImportsFromPoject = "ImportsFromPoject";
interface IncomingRelationExpr extends AstNode {
  readonly $container: Expressions | InOutRelationExpr | RelationExprWhere | RelationExprWith;
  readonly $type: 'IncomingRelationExpr';
  to: FqnExpr$2;
}
declare const IncomingRelationExpr = "IncomingRelationExpr";
interface InOutRelationExpr extends AstNode {
  readonly $container: Expressions | RelationExprWhere | RelationExprWith;
  readonly $type: 'InOutRelationExpr';
  inout: IncomingRelationExpr;
}
declare const InOutRelationExpr = "InOutRelationExpr";
interface LibIcon extends AstNode {
  readonly $container: LikeC4Lib;
  readonly $type: 'LibIcon';
  name: IconId;
}
declare const LibIcon = "LibIcon";
interface LikeC4Grammar extends AstNode {
  readonly $type: 'LikeC4Grammar';
  deployments: Array<ModelDeployments>;
  globals: Array<Globals>;
  imports: Array<ImportsFromPoject>;
  likec4lib: Array<LikeC4Lib>;
  models: Array<Model>;
  specifications: Array<SpecificationRule>;
  views: Array<ModelViews>;
}
declare const LikeC4Grammar = "LikeC4Grammar";
interface LikeC4Lib extends AstNode {
  readonly $container: LikeC4Grammar;
  readonly $type: 'LikeC4Lib';
  icons: Array<LibIcon>;
}
declare const LikeC4Lib = "LikeC4Lib";
interface LineProperty extends AstNode {
  readonly $container: CustomRelationProperties | RelationStyleProperty | SpecificationRelationshipKind;
  readonly $type: 'LineProperty';
  key: 'line';
  value: LineOptions;
}
declare const LineProperty = "LineProperty";
interface LinkProperty extends AstNode {
  readonly $container: DeployedInstanceBody | DeploymentNodeBody | DeploymentRelationBody | DeploymentViewBody | DynamicViewBody | ElementBody | ElementViewBody | ExtendDeploymentBody | ExtendElementBody | ExtendRelationBody | RelationBody | SpecificationDeploymentNodeKind | SpecificationElementKind;
  readonly $type: 'LinkProperty';
  key: 'link';
  title?: string;
  value: Uri;
}
declare const LinkProperty = "LinkProperty";
interface MarkdownOrString extends AstNode {
  readonly $container: ElementStringProperty | MetadataArray | MetadataAttribute | NotationProperty | NotesProperty | RelationStringProperty | SpecificationElementStringProperty | SpecificationRelationshipStringProperty | ViewStringProperty;
  readonly $type: 'MarkdownOrString';
  markdown?: string;
  text?: string;
}
declare const MarkdownOrString = "MarkdownOrString";
interface MetadataArray extends AstNode {
  readonly $container: MetadataAttribute;
  readonly $type: 'MetadataArray';
  values: Array<MarkdownOrString>;
}
declare const MetadataArray = "MetadataArray";
interface MetadataAttribute extends AstNode {
  readonly $container: MetadataBody;
  readonly $type: 'MetadataAttribute';
  boolValue: boolean;
  key: Id;
  value?: MetadataValue;
}
declare const MetadataAttribute = "MetadataAttribute";
interface MetadataBody extends AstNode {
  readonly $container: DeployedInstanceBody | DeploymentNodeBody | DeploymentRelationBody | ElementBody | ExtendDeploymentBody | ExtendElementBody | ExtendRelationBody | RelationBody;
  readonly $type: 'MetadataBody';
  props: Array<MetadataAttribute>;
}
declare const MetadataBody = "MetadataBody";
interface Model extends AstNode {
  readonly $container: LikeC4Grammar;
  readonly $type: 'Model';
  elements: Array<Element | ExtendElement | ExtendRelation | Relation>;
  name: 'model';
}
declare const Model = "Model";
interface ModelDeployments extends AstNode {
  readonly $container: LikeC4Grammar;
  readonly $type: 'ModelDeployments';
  elements: Array<DeploymentNode | DeploymentRelation | ExtendDeployment>;
  name: 'deployment';
}
declare const ModelDeployments = "ModelDeployments";
interface ModelViews extends AstNode {
  readonly $container: LikeC4Grammar;
  readonly $type: 'ModelViews';
  folder?: string;
  name: 'views';
  styles: Array<ViewRuleStyleOrGlobalRef>;
  views: Array<LikeC4View>;
}
declare const ModelViews = "ModelViews";
interface MultipleProperty extends AstNode {
  readonly $container: CustomElementProperties | CustomRelationProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | SpecificationRelationshipKind | ViewRuleStyle;
  readonly $type: 'MultipleProperty';
  key: 'multiple';
  value: boolean;
}
declare const MultipleProperty = "MultipleProperty";
interface NavigateToProperty extends AstNode {
  readonly $container: CustomElementProperties;
  readonly $type: 'NavigateToProperty';
  key: 'navigateTo';
  value: ViewRef;
}
declare const NavigateToProperty = "NavigateToProperty";
interface NotationProperty extends AstNode {
  readonly $container: CustomElementProperties | CustomRelationProperties | DeploymentViewRuleStyle | GlobalStyle | ViewRuleStyle;
  readonly $type: 'NotationProperty';
  key: 'notation';
  value: MarkdownOrString;
}
declare const NotationProperty = "NotationProperty";
interface NotesProperty extends AstNode {
  readonly $container: CustomElementProperties | CustomRelationProperties;
  readonly $type: 'NotesProperty';
  key: 'notes';
  value: MarkdownOrString;
}
declare const NotesProperty = "NotesProperty";
interface OpacityProperty extends AstNode {
  readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleGroup | ViewRuleStyle;
  readonly $type: 'OpacityProperty';
  key: 'opacity';
  value: string;
}
declare const OpacityProperty = "OpacityProperty";
interface OutgoingRelationExpr extends AstNode {
  readonly $container: DirectedRelationExpr | Expressions | RelationExprWhere | RelationExprWith;
  readonly $type: 'OutgoingRelationExpr';
  dotKind?: RelationKindDotRef;
  from: FqnExpr$2;
  isBidirectional: boolean;
  kind?: Reference<RelationshipKind>;
}
declare const OutgoingRelationExpr = "OutgoingRelationExpr";
interface PaddingSizeProperty extends AstNode {
  readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
  readonly $type: 'PaddingSizeProperty';
  key: 'padding';
  value: SizeValue;
}
declare const PaddingSizeProperty = "PaddingSizeProperty";
interface Relation extends AstNode {
  readonly $container: ElementBody | ExtendElementBody | Model;
  readonly $type: 'Relation';
  body?: RelationBody;
  description?: string;
  dotKind?: RelationKindDotRef;
  kind?: Reference<RelationshipKind>;
  source?: FqnRef$2;
  tags?: Tags;
  target: FqnRef$2;
  technology?: string;
  title?: string;
}
declare const Relation = "Relation";
interface RelationBody extends AstNode {
  readonly $container: Relation;
  readonly $type: 'RelationBody';
  props: Array<RelationProperty>;
  tags?: Tags;
}
declare const RelationBody = "RelationBody";
interface RelationExprWhere extends AstNode {
  readonly $container: Expressions | RelationExprWith;
  readonly $type: 'RelationExprWhere';
  subject: RelationExpr$1;
  where?: WhereRelationExpression;
}
declare const RelationExprWhere = "RelationExprWhere";
interface RelationExprWith extends AstNode {
  readonly $container: Expressions;
  readonly $type: 'RelationExprWith';
  custom?: CustomRelationProperties;
  subject: RelationExprOrWhere;
}
declare const RelationExprWith = "RelationExprWith";
interface RelationKindDotRef extends AstNode {
  readonly $container: AbstractDynamicStep | DeploymentRelation | ExtendRelation | OutgoingRelationExpr | Relation;
  readonly $type: 'RelationKindDotRef';
  kind: Reference<RelationshipKind>;
}
declare const RelationKindDotRef = "RelationKindDotRef";
interface RelationNavigateToProperty extends AstNode {
  readonly $container: CustomRelationProperties | DeploymentRelationBody | RelationBody;
  readonly $type: 'RelationNavigateToProperty';
  key: 'navigateTo';
  value: DynamicViewRef;
}
declare const RelationNavigateToProperty = "RelationNavigateToProperty";
interface RelationshipKind extends AstNode {
  readonly $container: SpecificationRelationshipKind;
  readonly $type: 'RelationshipKind';
  name: Id;
}
declare const RelationshipKind = "RelationshipKind";
interface RelationStringProperty extends AstNode {
  readonly $container: CustomRelationProperties | DeploymentRelationBody | RelationBody;
  readonly $type: 'RelationStringProperty';
  key: 'description' | 'technology' | 'title';
  value: MarkdownOrString;
}
declare const RelationStringProperty = "RelationStringProperty";
interface RelationStyleProperty extends AstNode {
  readonly $container: DeploymentRelationBody | RelationBody;
  readonly $type: 'RelationStyleProperty';
  key: 'style';
  props: Array<RelationshipStyleProperty>;
}
declare const RelationStyleProperty = "RelationStyleProperty";
interface RGBAColor extends AstNode {
  readonly $container: SpecificationColor | SpecificationTag;
  readonly $type: 'RGBAColor';
  alpha?: number | string;
  blue: number;
  green: number;
  red: number;
}
declare const RGBAColor = "RGBAColor";
interface ShapeProperty extends AstNode {
  readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
  readonly $type: 'ShapeProperty';
  key: 'shape';
  value: ElementShape;
}
declare const ShapeProperty = "ShapeProperty";
interface ShapeSizeProperty extends AstNode {
  readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
  readonly $type: 'ShapeSizeProperty';
  key: 'size';
  value: SizeValue;
}
declare const ShapeSizeProperty = "ShapeSizeProperty";
interface SpecificationColor extends AstNode {
  readonly $container: SpecificationRule;
  readonly $type: 'SpecificationColor';
  color: ColorLiteral$1;
  name: CustomColor;
}
declare const SpecificationColor = "SpecificationColor";
interface SpecificationDeploymentNodeKind extends AstNode {
  readonly $container: SpecificationRule;
  readonly $type: 'SpecificationDeploymentNodeKind';
  kind: DeploymentNodeKind;
  props: Array<ElementStyleProperty | LinkProperty | SpecificationElementStringProperty>;
  tags?: Tags;
}
declare const SpecificationDeploymentNodeKind = "SpecificationDeploymentNodeKind";
interface SpecificationElementKind extends AstNode {
  readonly $container: SpecificationRule;
  readonly $type: 'SpecificationElementKind';
  kind: ElementKind;
  props: Array<ElementStyleProperty | LinkProperty | SpecificationElementStringProperty>;
  tags?: Tags;
}
declare const SpecificationElementKind = "SpecificationElementKind";
interface SpecificationElementStringProperty extends AstNode {
  readonly $container: SpecificationDeploymentNodeKind | SpecificationElementKind;
  readonly $type: 'SpecificationElementStringProperty';
  key: 'description' | 'notation' | 'summary' | 'technology' | 'title';
  value: MarkdownOrString;
}
declare const SpecificationElementStringProperty = "SpecificationElementStringProperty";
interface SpecificationRelationshipKind extends AstNode {
  readonly $container: SpecificationRule;
  readonly $type: 'SpecificationRelationshipKind';
  kind: RelationshipKind;
  props: Array<MultipleProperty | RelationshipStyleProperty | SpecificationRelationshipStringProperty>;
}
declare const SpecificationRelationshipKind = "SpecificationRelationshipKind";
interface SpecificationRelationshipStringProperty extends AstNode {
  readonly $container: SpecificationRelationshipKind;
  readonly $type: 'SpecificationRelationshipStringProperty';
  key: 'notation' | 'technology';
  value: MarkdownOrString;
}
declare const SpecificationRelationshipStringProperty = "SpecificationRelationshipStringProperty";
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>;
}
declare const SpecificationRule = "SpecificationRule";
interface SpecificationTag extends AstNode {
  readonly $container: SpecificationRule;
  readonly $type: 'SpecificationTag';
  color?: ColorLiteral$1;
  tag: Tag$1;
}
declare const SpecificationTag = "SpecificationTag";
interface StrictFqnElementRef extends AstNode {
  readonly $container: ExtendElement | StrictFqnElementRef;
  readonly $type: 'StrictFqnElementRef';
  el: Reference<Element>;
  parent?: StrictFqnElementRef;
}
declare const StrictFqnElementRef = "StrictFqnElementRef";
interface StrictFqnRef extends AstNode {
  readonly $container: ExtendDeployment | StrictFqnRef;
  readonly $type: 'StrictFqnRef';
  parent?: StrictFqnRef;
  value: Reference<Referenceable>;
}
declare const StrictFqnRef = "StrictFqnRef";
interface Tag$1 extends AstNode {
  readonly $container: SpecificationTag;
  readonly $type: 'Tag';
  name: Id;
}
declare const Tag$1 = "Tag";
interface TagRef extends AstNode {
  readonly $container: ElementTagExpression | Tags | WhereElementTag | WhereRelationParticipantTag | WhereRelationTag;
  readonly $type: 'TagRef';
  tag: Reference<Tag$1>;
}
declare const TagRef = "TagRef";
interface Tags extends AstNode {
  readonly $container: DeployedInstanceBody | DeploymentNodeBody | DeploymentRelation | DeploymentRelationBody | DeploymentViewBody | DynamicViewBody | ElementBody | ElementViewBody | ExtendDeploymentBody | ExtendElementBody | ExtendRelationBody | Relation | RelationBody | SpecificationDeploymentNodeKind | SpecificationElementKind | Tags;
  readonly $type: 'Tags';
  prev?: Tags;
  values: Array<TagRef>;
}
declare const Tags = "Tags";
interface TextSizeProperty extends AstNode {
  readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
  readonly $type: 'TextSizeProperty';
  key: 'textSize';
  value: SizeValue;
}
declare const TextSizeProperty = "TextSizeProperty";
interface ViewRef extends AstNode {
  readonly $container: NavigateToProperty;
  readonly $type: 'ViewRef';
  view: Reference<LikeC4View>;
}
declare const ViewRef = "ViewRef";
interface ViewRuleAncestors extends AstNode {
  readonly $container: DeploymentViewBody;
  readonly $type: 'ViewRuleAncestors';
  key: 'includeAncestors';
  value: boolean;
}
declare const ViewRuleAncestors = "ViewRuleAncestors";
interface ViewRuleAutoLayout extends AstNode {
  readonly $container: DeploymentViewBody | DynamicViewBody | ElementViewBody;
  readonly $type: 'ViewRuleAutoLayout';
  direction: ViewLayoutDirection;
  nodeSep?: number;
  rankSep?: number;
}
declare const ViewRuleAutoLayout = "ViewRuleAutoLayout";
interface ViewRuleGlobalPredicateRef extends AstNode {
  readonly $container: ElementViewBody;
  readonly $type: 'ViewRuleGlobalPredicateRef';
  predicate: Reference<GlobalPredicateGroup>;
}
declare const ViewRuleGlobalPredicateRef = "ViewRuleGlobalPredicateRef";
interface ViewRuleGlobalStyle extends AstNode {
  readonly $container: DynamicViewBody | ElementViewBody | ModelViews;
  readonly $type: 'ViewRuleGlobalStyle';
  style: Reference<GlobalStyleId>;
}
declare const ViewRuleGlobalStyle = "ViewRuleGlobalStyle";
interface ViewRuleGroup extends AstNode {
  readonly $container: ElementViewBody | ViewRuleGroup;
  readonly $type: 'ViewRuleGroup';
  groupRules: Array<ViewRuleGroup | ViewRulePredicate>;
  props: Array<BorderProperty | ColorProperty | OpacityProperty>;
  title?: string;
}
declare const ViewRuleGroup = "ViewRuleGroup";
interface ViewRulePredicate extends AstNode {
  readonly $container: ElementViewBody | GlobalPredicateGroup | ViewRuleGroup;
  readonly $type: 'ViewRulePredicate';
  exprs: Expressions;
  isInclude: boolean;
}
declare const ViewRulePredicate = "ViewRulePredicate";
interface ViewRuleRank extends AstNode {
  readonly $container: ElementViewBody;
  readonly $type: 'ViewRuleRank';
  targets: FqnExpressions;
  value?: RankValue;
}
declare const ViewRuleRank = "ViewRuleRank";
interface ViewRuleStyle extends AstNode {
  readonly $container: DynamicViewBody | ElementViewBody | GlobalStyleGroup | ModelViews;
  readonly $type: 'ViewRuleStyle';
  props: Array<NotationProperty | StyleProperty>;
  targets: FqnExpressions;
}
declare const ViewRuleStyle = "ViewRuleStyle";
interface ViewStringProperty extends AstNode {
  readonly $container: DeploymentViewBody | DynamicViewBody | ElementViewBody;
  readonly $type: 'ViewStringProperty';
  key: 'description' | 'title';
  value: MarkdownOrString;
}
declare const ViewStringProperty = "ViewStringProperty";
interface WhereBinaryExpression extends AstNode {
  readonly $container: FqnExprWhere | RelationExprWhere | WhereBinaryExpression | WhereElementNegation | WhereRelationNegation;
  readonly $type: 'WhereBinaryExpression';
  left: WhereElementExpression | WhereRelationExpression;
  operator: 'and' | 'or';
  right: WhereElementExpression | WhereRelationExpression;
}
declare const WhereBinaryExpression = "WhereBinaryExpression";
interface WhereElementKind extends AstNode {
  readonly $container: FqnExprWhere | WhereBinaryExpression | WhereElementNegation;
  readonly $type: 'WhereElementKind';
  not: boolean;
  operator: 'is' | string;
  value: Reference<DeploymentNodeOrElementKind>;
}
declare const WhereElementKind = "WhereElementKind";
interface WhereElementMetadata extends AstNode {
  readonly $container: FqnExprWhere | WhereBinaryExpression | WhereElementNegation;
  readonly $type: 'WhereElementMetadata';
  key: Id;
  not: boolean;
  operator?: 'is' | string;
  value?: MetadataFilterValue;
}
declare const WhereElementMetadata = "WhereElementMetadata";
interface WhereElementNegation extends AstNode {
  readonly $container: FqnExprWhere | WhereBinaryExpression | WhereElementNegation;
  readonly $type: 'WhereElementNegation';
  value: WhereElementExpression;
}
declare const WhereElementNegation = "WhereElementNegation";
interface WhereElementTag extends AstNode {
  readonly $container: FqnExprWhere | WhereBinaryExpression | WhereElementNegation;
  readonly $type: 'WhereElementTag';
  not: boolean;
  operator: 'is' | string;
  value: TagRef;
}
declare const WhereElementTag = "WhereElementTag";
interface WhereRelationKind extends AstNode {
  readonly $container: RelationExprWhere | WhereBinaryExpression | WhereRelationNegation;
  readonly $type: 'WhereRelationKind';
  not: boolean;
  operator: 'is' | string;
  value: Reference<RelationshipKind>;
}
declare const WhereRelationKind = "WhereRelationKind";
interface WhereRelationMetadata extends AstNode {
  readonly $container: RelationExprWhere | WhereBinaryExpression | WhereRelationNegation;
  readonly $type: 'WhereRelationMetadata';
  key: Id;
  not: boolean;
  operator?: 'is' | string;
  value?: MetadataFilterValue;
}
declare const WhereRelationMetadata = "WhereRelationMetadata";
interface WhereRelationNegation extends AstNode {
  readonly $container: RelationExprWhere | WhereBinaryExpression | WhereRelationNegation;
  readonly $type: 'WhereRelationNegation';
  value: WhereRelationExpression;
}
declare const WhereRelationNegation = "WhereRelationNegation";
interface WhereRelationParticipantKind extends AstNode {
  readonly $container: RelationExprWhere | WhereBinaryExpression | WhereRelationNegation;
  readonly $type: 'WhereRelationParticipantKind';
  not: boolean;
  operator: 'is' | string;
  participant: Participant;
  value: Reference<DeploymentNodeOrElementKind>;
}
declare const WhereRelationParticipantKind = "WhereRelationParticipantKind";
interface WhereRelationParticipantMetadata extends AstNode {
  readonly $container: RelationExprWhere | WhereBinaryExpression | WhereRelationNegation;
  readonly $type: 'WhereRelationParticipantMetadata';
  key: Id;
  not: boolean;
  operator?: 'is' | string;
  participant: Participant;
  value?: MetadataFilterValue;
}
declare const WhereRelationParticipantMetadata = "WhereRelationParticipantMetadata";
interface WhereRelationParticipantTag extends AstNode {
  readonly $container: RelationExprWhere | WhereBinaryExpression | WhereRelationNegation;
  readonly $type: 'WhereRelationParticipantTag';
  not: boolean;
  operator: 'is' | string;
  participant: Participant;
  value: TagRef;
}
declare const WhereRelationParticipantTag = "WhereRelationParticipantTag";
interface WhereRelationTag extends AstNode {
  readonly $container: RelationExprWhere | WhereBinaryExpression | WhereRelationNegation;
  readonly $type: 'WhereRelationTag';
  not: boolean;
  operator: 'is' | string;
  value: TagRef;
}
declare const WhereRelationTag = "WhereRelationTag";
interface WildcardExpression extends AstNode {
  readonly $container: DirectedRelationExpr | Expressions | FqnExprWhere | FqnExprWith | FqnExpressions | IncomingRelationExpr | OutgoingRelationExpr;
  readonly $type: 'WildcardExpression';
  isWildcard: boolean;
}
declare const WildcardExpression = "WildcardExpression";
interface DynamicStepChain extends AbstractDynamicStep {
  readonly $container: DynamicStepChain | DynamicViewBody | DynamicViewParallelSteps;
  readonly $type: 'DynamicStepChain';
  source: DynamicStepChain | DynamicStepSingle;
}
declare const DynamicStepChain = "DynamicStepChain";
interface DynamicStepSingle extends AbstractDynamicStep {
  readonly $container: DynamicStepChain | DynamicViewBody | DynamicViewParallelSteps;
  readonly $type: 'DynamicStepSingle';
  isBackward: boolean;
  source: ElementRef;
}
declare const DynamicStepSingle = "DynamicStepSingle";
type LikeC4AstType = {
  AbstractDynamicStep: AbstractDynamicStep;
  AnyProperty: AnyProperty;
  ArrowProperty: ArrowProperty;
  BorderProperty: BorderProperty;
  ColorLiteral: ColorLiteral$1;
  ColorProperty: ColorProperty;
  CustomColor: CustomColor;
  CustomElementProperties: CustomElementProperties;
  CustomRelationProperties: CustomRelationProperties;
  DeployedInstance: DeployedInstance;
  DeployedInstanceBody: DeployedInstanceBody;
  DeploymentElement: DeploymentElement;
  DeploymentNode: DeploymentNode;
  DeploymentNodeBody: DeploymentNodeBody;
  DeploymentNodeKind: DeploymentNodeKind;
  DeploymentNodeOrElementKind: DeploymentNodeOrElementKind;
  DeploymentRelation: DeploymentRelation;
  DeploymentRelationBody: DeploymentRelationBody;
  DeploymentView: DeploymentView;
  DeploymentViewBody: DeploymentViewBody;
  DeploymentViewRule: DeploymentViewRule;
  DeploymentViewRulePredicate: DeploymentViewRulePredicate;
  DeploymentViewRuleStyle: DeploymentViewRuleStyle;
  DirectedRelationExpr: DirectedRelationExpr;
  DynamicStepChain: DynamicStepChain;
  DynamicStepSingle: DynamicStepSingle;
  DynamicView: DynamicView;
  DynamicViewBody: DynamicViewBody;
  DynamicViewDisplayVariantProperty: DynamicViewDisplayVariantProperty;
  DynamicViewGlobalPredicateRef: DynamicViewGlobalPredicateRef;
  DynamicViewIncludePredicate: DynamicViewIncludePredicate;
  DynamicViewParallelSteps: DynamicViewParallelSteps;
  DynamicViewProperty: DynamicViewProperty;
  DynamicViewRef: DynamicViewRef;
  DynamicViewRule: DynamicViewRule;
  DynamicViewStep: DynamicViewStep;
  Element: Element;
  ElementBody: ElementBody;
  ElementKind: ElementKind;
  ElementKindExpression: ElementKindExpression;
  ElementProperty: ElementProperty;
  ElementRef: ElementRef;
  ElementStringProperty: ElementStringProperty;
  ElementStyleProperty: ElementStyleProperty;
  ElementTagExpression: ElementTagExpression;
  ElementView: ElementView;
  ElementViewBody: ElementViewBody;
  ElementViewRef: ElementViewRef;
  ExpressionV2: ExpressionV2;
  Expressions: Expressions;
  ExtendDeployment: ExtendDeployment;
  ExtendDeploymentBody: ExtendDeploymentBody;
  ExtendElement: ExtendElement;
  ExtendElementBody: ExtendElementBody;
  ExtendElementProperty: ExtendElementProperty;
  ExtendRelation: ExtendRelation;
  ExtendRelationBody: ExtendRelationBody;
  ExtendRelationProperty: ExtendRelationProperty;
  FqnExpr: FqnExpr$2;
  FqnExprOrWhere: FqnExprOrWhere;
  FqnExprOrWith: FqnExprOrWith;
  FqnExprWhere: FqnExprWhere;
  FqnExprWith: FqnExprWith;
  FqnExpressions: FqnExpressions;
  FqnRef: FqnRef$2;
  FqnRefExpr: FqnRefExpr;
  FqnReferenceable: FqnReferenceable;
  GlobalDynamicPredicateGroup: GlobalDynamicPredicateGroup;
  GlobalPredicateGroup: GlobalPredicateGroup;
  GlobalStyle: GlobalStyle;
  GlobalStyleGroup: GlobalStyleGroup;
  GlobalStyleId: GlobalStyleId;
  Globals: Globals;
  HexColor: HexColor;
  IconColorProperty: IconColorProperty;
  IconPositionProperty: IconPositionProperty;
  IconProperty: IconProperty;
  IconSizeProperty: IconSizeProperty;
  Imported: Imported;
  ImportsFromPoject: ImportsFromPoject;
  InOutRelationExpr: InOutRelationExpr;
  IncomingRelationExpr: IncomingRelationExpr;
  LibIcon: LibIcon;
  LikeC4Grammar: LikeC4Grammar;
  LikeC4Lib: LikeC4Lib;
  LikeC4View: LikeC4View;
  LineProperty: LineProperty;
  LinkProperty: LinkProperty;
  MarkdownOrString: MarkdownOrString;
  MetadataArray: MetadataArray;
  MetadataAttribute: MetadataAttribute;
  MetadataBody: MetadataBody;
  MetadataProperty: MetadataProperty;
  MetadataValue: MetadataValue;
  Model: Model;
  ModelDeployments: ModelDeployments;
  ModelReferenceable: ModelReferenceable;
  ModelViews: ModelViews;
  MultipleProperty: MultipleProperty;
  NavigateToProperty: NavigateToProperty;
  NotationProperty: NotationProperty;
  NotesProperty: NotesProperty;
  OpacityProperty: OpacityProperty;
  OutgoingRelationExpr: OutgoingRelationExpr;
  PaddingSizeProperty: PaddingSizeProperty;
  RGBAColor: RGBAColor;
  Referenceable: Referenceable;
  Relation: Relation;
  RelationBody: RelationBody;
  RelationExpr: RelationExpr$1;
  RelationExprOrWhere: RelationExprOrWhere;
  RelationExprOrWith: RelationExprOrWith;
  RelationExprWhere: RelationExprWhere;
  RelationExprWith: RelationExprWith;
  RelationKindDotRef: RelationKindDotRef;
  RelationNavigateToProperty: RelationNavigateToProperty;
  RelationProperty: RelationProperty;
  RelationStringProperty: RelationStringProperty;
  RelationStyleProperty: RelationStyleProperty;
  RelationshipKind: RelationshipKind;
  RelationshipStyleProperty: RelationshipStyleProperty;
  ShapeProperty: ShapeProperty;
  ShapeSizeProperty: ShapeSizeProperty;
  SizeProperty: SizeProperty;
  SpecificationColor: SpecificationColor;
  SpecificationDeploymentNodeKind: SpecificationDeploymentNodeKind;
  SpecificationElementKind: SpecificationElementKind;
  SpecificationElementStringProperty: SpecificationElementStringProperty;
  SpecificationRelationshipKind: SpecificationRelationshipKind;
  SpecificationRelationshipStringProperty: SpecificationRelationshipStringProperty;
  SpecificationRule: SpecificationRule;
  SpecificationTag: SpecificationTag;
  StrictFqnElementRef: StrictFqnElementRef;
  StrictFqnRef: StrictFqnRef;
  StringProperty: StringProperty;
  StyleProperty: StyleProperty;
  Tag: Tag$1;
  TagRef: TagRef;
  Tags: Tags;
  TextSizeProperty: TextSizeProperty;
  ViewProperty: ViewProperty;
  ViewRef: ViewRef;
  ViewRule: ViewRule;
  ViewRuleAncestors: ViewRuleAncestors;
  ViewRuleAutoLayout: ViewRuleAutoLayout;
  ViewRuleGlobalPredicateRef: ViewRuleGlobalPredicateRef;
  ViewRuleGlobalStyle: ViewRuleGlobalStyle;
  ViewRuleGroup: ViewRuleGroup;
  ViewRulePredicate: ViewRulePredicate;
  ViewRuleRank: ViewRuleRank;
  ViewRuleStyle: ViewRuleStyle;
  ViewRuleStyleOrGlobalRef: ViewRuleStyleOrGlobalRef;
  ViewStringProperty: ViewStringProperty;
  WhereBinaryExpression: WhereBinaryExpression;
  WhereElement: WhereElement;
  WhereElementExpression: WhereElementExpression;
  WhereElementKind: WhereElementKind;
  WhereElementMetadata: WhereElementMetadata;
  WhereElementNegation: WhereElementNegation;
  WhereElementTag: WhereElementTag;
  WhereExpression: WhereExpression;
  WhereKindEqual: WhereKindEqual;
  WhereMetadataEqual: WhereMetadataEqual;
  WhereRelation: WhereRelation;
  WhereRelationExpression: WhereRelationExpression;
  WhereRelationKind: WhereRelationKind;
  WhereRelationMetadata: WhereRelationMetadata;
  WhereRelationNegation: WhereRelationNegation;
  WhereRelationParticipantKind: WhereRelationParticipantKind;
  WhereRelationParticipantMetadata: WhereRelationParticipantMetadata;
  WhereRelationParticipantTag: WhereRelationParticipantTag;
  WhereRelationTag: WhereRelationTag;
  WhereTagEqual: WhereTagEqual;
  WildcardExpression: WildcardExpression;
}; //#endregion
//#region src/validation/DocumentValidator.d.ts
declare class LikeC4DocumentValidator extends DefaultDocumentValidator {
  protected services: LikeC4Services;
  constructor(services: LikeC4Services);
  /**
   * If the document is excluded, then we skip validation and return an empty array of diagnostics.
   */
  validateDocument(document: LangiumDocument, options?: ValidationOptions, cancelToken?: CancellationToken$1): Promise<Diagnostic[]>;
} //#endregion
//#region src/validation/index.d.ts
declare const isValidatableAstNode: any;
type ValidatableAstNode = GuardedBy<typeof isValidatableAstNode>;
declare function checksFromDiagnostics(doc: LikeC4LangiumDocument): {
  isValid: (n: ValidatableAstNode) => boolean;
  invalidNodes: WeakSet<WeakKey>;
};
type ChecksFromDiagnostics = ReturnType<typeof checksFromDiagnostics>;
type IsValidFn = ChecksFromDiagnostics['isValid']; //#endregion
//#region src/ast.d.ts
declare module 'langium' {
  interface LangiumDocument {
    likec4ProjectId?: c4.ProjectId;
  }
  interface AstNodeDescription {
    likec4ProjectId?: c4.ProjectId;
  }
}
declare const idattr: unique symbol;
declare module './generated/ast' {
  interface Element {
    [idattr]?: c4.Fqn | undefined;
  }
  interface ElementView {
    [idattr]?: c4.ViewId | undefined;
  }
  interface DynamicView {
    [idattr]?: c4.ViewId | undefined;
  }
  interface DeploymentView {
    [idattr]?: c4.ViewId | undefined;
  }
  interface DeploymentNode {
    [idattr]?: c4.Fqn | undefined;
  }
  interface DeployedInstance {
    [idattr]?: c4.Fqn | undefined;
  }
}
type ParsedElementStyle = {
  shape?: c4.ElementShape;
  icon?: c4.IconUrl;
  iconColor?: c4.Color;
  iconSize?: c4.ShapeSize;
  iconPosition?: c4.IconPosition;
  color?: c4.Color;
  border?: c4.BorderStyle;
  opacity?: number;
  multiple?: boolean;
  size?: c4.ShapeSize;
  padding?: c4.SpacingSize;
  textSize?: c4.TextSize;
};
interface ParsedAstSpecification {
  tags: Record<c4.Tag, {
    astPath: string;
    color?: c4.ColorLiteral;
  }>;
  elements: Record<c4.ElementKind, c4.ElementSpecification>;
  relationships: Record<c4.RelationshipKind, {
    technology?: string;
    notation?: string;
    color?: c4.Color;
    line?: c4.RelationshipLineType;
    head?: c4.RelationshipArrowType;
    tail?: c4.RelationshipArrowType;
    multiple?: boolean;
  }>;
  colors: Record<c4.CustomColor, {
    color: c4.ColorLiteral;
  }>;
  deployments: Record<c4.DeploymentKind, c4.ElementSpecification>;
}
interface ParsedAstElement {
  id: c4.Fqn;
  astPath: string;
  kind: c4.ElementKind;
  title?: string;
  summary?: c4.MarkdownOrString;
  description?: c4.MarkdownOrString;
  technology?: string;
  tags?: c4.NonEmptyArray<c4.Tag>;
  links?: c4.NonEmptyArray<c4.Link>;
  style: ParsedElementStyle;
  metadata?: {
    [key: string]: string | string[];
  };
}
interface ParsedAstExtend {
  id: c4.Fqn;
  astPath: string;
  tags?: c4.NonEmptyArray<c4.Tag> | null;
  links?: c4.NonEmptyArray<c4.Link> | null;
  metadata?: {
    [key: string]: string | string[];
  };
}
interface ParsedAstExtendRelation {
  id: c4.RelationId;
  astPath: string;
  tags?: c4.NonEmptyArray<c4.Tag> | null;
  links?: c4.NonEmptyArray<c4.Link> | null;
  metadata?: {
    [key: string]: string | string[];
  };
}
interface ParsedAstRelation {
  id: c4.RelationId;
  astPath: string;
  source: c4.FqnRef.ModelRef;
  target: c4.FqnRef.ModelRef;
  kind?: c4.RelationshipKind;
  tags?: c4.NonEmptyArray<c4.Tag>;
  title: string;
  description?: c4.MarkdownOrString;
  technology?: string;
  color?: c4.Color;
  line?: c4.RelationshipLineType;
  head?: c4.RelationshipArrowType;
  tail?: c4.RelationshipArrowType;
  links?: c4.NonEmptyArray<c4.Link>;
  navigateTo?: c4.ViewId;
  metadata?: {
    [key: string]: string | string[];
  };
}
type ParsedAstDeployment = Simplify<MergeExclusive<ParsedAstDeployment.Node, ParsedAstDeployment.Instance>>;
declare namespace ParsedAstDeployment {
  type Node = c4.DeploymentNode;
  type Instance = Omit<c4.DeployedInstance, 'element'> & {
    readonly element: c4.FqnRef.ModelRef;
  };
}
type ParsedAstDeploymentRelation = c4.DeploymentRelationship & {
  astPath: string;
};
type ParsedAstGlobals = Writable<c4.ModelGlobals>;
interface ParsedAstElementView {
  id: c4.ViewId;
  viewOf?: c4.Fqn;
  extends?: c4.ViewId;
  astPath: string;
  title: string | null;
  description: c4.MarkdownOrString | null;
  tags: c4.NonEmptyArray<c4.Tag> | null;
  links: c4.NonEmptyArray<c4.Link> | null;
  rules: c4.ElementViewRule[];
}
interface ParsedAstDynamicView {
  id: c4.ViewId;
  astPath: string;
  title: string | null;
  description: c4.MarkdownOrString | null;
  tags: c4.NonEmptyArray<c4.Tag> | null;
  links: c4.NonEmptyArray<c4.Link> | null;
  steps: c4.DynamicViewStep[];
  rules: Array<c4.DynamicViewRule>;
  variant: c4.DynamicViewDisplayVariant | undefined;
}
interface ParsedAstDeploymentView {
  id: c4.ViewId;
  astPath: string;
  title: string | null;
  description: c4.MarkdownOrString | null;
  tags: c4.NonEmptyArray<c4.Tag> | null;
  links: c4.NonEmptyArray<c4.Link> | null;
  rules: Array<c4.DeploymentViewRule>;
}
type ParsedAstView = ParsedAstElementView | ParsedAstDynamicView | ParsedAstDeploymentView;
interface AstNodeDescriptionWithFqn extends AstNodeDescription {
  likec4ProjectId: c4.ProjectId;
  id: c4.Fqn;
}
type LikeC4AstNode = ValueOf<ConditionalPick<LikeC4AstType, AstNode>>;
type LikeC4DocumentDiagnostic = Diagnostic & DiagnosticInfo<LikeC4AstNode>;
interface LikeC4DocumentProps {
  diagnostics?: Array<LikeC4DocumentDiagnostic>;
  c4Specification?: ParsedAstSpecification;
  c4Elements?: ParsedAstElement[];
  c4ExtendElements?: ParsedAstExtend[];
  c4ExtendDeployments?: ParsedAstExtend[];
  c4ExtendRelations?: ParsedAstExtendRelation[];
  c4Relations?: ParsedAstRelation[];
  c4Globals?: ParsedAstGlobals;
  c4Views?: ParsedAstView[];
  c4Deployments?: ParsedAstDeployment[];
  c4DeploymentRelations?: ParsedAstDeploymentRelation[];
  c4Imports?: MultiMap<c4.ProjectId, c4.Fqn, Set<c4.Fqn>>;
}
type LikeC4GrammarDocument = Omit<LangiumDocument<LikeC4Grammar>, 'diagnostics'>;
interface LikeC4LangiumDocument extends LikeC4GrammarDocument, LikeC4DocumentProps {
  likec4ProjectId: c4.ProjectId;
}
interface ParsedLikeC4LangiumDocument extends LikeC4GrammarDocument, Required<LikeC4DocumentProps> {
  likec4ProjectId: c4.ProjectId;
} //#endregion
//#region src/references/name-provider.d.ts
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;
} //#endregion
//#region src/references/scope-computation.d.ts
type ElementsContainer = Model | ElementBody | ExtendElementBody;
type DeploymentsContainer = ModelDeployments | DeploymentNodeBody | ExtendDeploymentBody | DeployedInstanceBody;
declare class LikeC4ScopeComputation extends DefaultScopeComputation {
  constructor(services: LikeC4Services);
  computeExports(document: LikeC4LangiumDocument, _cancelToken?: CancellationToken$1): Promise<AstNodeDescription[]>;
  private exportViews;
  private exportGlobals;
  private exportModel;
  private exportLibrary;
  private exportSpecification;
  private exportDeployments;
  computeLocalScopes(document: LikeC4LangiumDocument, _cancelToken?: CancellationToken$1): Promise<PrecomputedScopes>;
  protected processContainer(container: ElementsContainer, scopes: PrecomputedScopes, document: LikeC4LangiumDocument): AstNodeDescription[];
  protected processDeployments(container: DeploymentsContainer, scopes: PrecomputedScopes, document: LikeC4LangiumDocument): AstNodeDescription[];
} //#endregion
//#region src/workspace/IndexManager.d.ts
declare class IndexManager extends DefaultIndexManager {
  protected services: LikeC4SharedServices;
  constructor(services: LikeC4SharedServices);
  updateContent(document: LangiumDocument, cancelToken?: CancellationToken$1): Promise<void>;
  projectElements(projectId: ProjectId$1, nodeType?: string, uris?: Set<string>): Stream<AstNodeDescription>;
} //#endregion
//#region src/workspace/LangiumDocuments.d.ts
declare class LangiumDocuments extends DefaultLangiumDocuments {
  protected services: LikeC4SharedServices;
  constructor(services: LikeC4SharedServices);
  protected get projectsManager(): ProjectsManager;
  addDocument(document: LangiumDocument): void;
  getDocument(uri: URI): LangiumDocument | undefined;
  /**
   * Returns all user documents
   */
  get userDocuments(): Stream<LikeC4LangiumDocument>;
  /**
   * Returns all documents (ensures project IDs are set)
   */
  get all(): Stream<LangiumDocument>;
  /**
   * Returns all documents for a project, including both project documents and documents included by the project.
   */
  projectDocuments(projectId: ProjectId$1): Stream<LikeC4LangiumDocument>;
  groupedByProject(): Record<ProjectId$1, NonEmptyArray$1<LikeC4LangiumDocument>>;
  /**
   * Reset the project IDs of all documents.
   * Returns the URIs
   */
  resetProjectIds(): URI[];
} //#endregion
//#region src/workspace/WorkspaceManager.d.ts
declare class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
  #private;
  private services;
  protected readonly documentFactory: LangiumDocumentFactory;
  protected readonly fileSystemProvider: FileSystemProvider$1;
  initialBuildOptions: BuildOptions;
  constructor(services: LikeC4SharedServices);
  /**
   * Whether the workspace is ready, use {@link ready} promise to wait for it
   */
  get isReady(): boolean;
  /**
   * First load all project config files, then load all documents in the workspace.
   */
  protected performStartup(folders: WorkspaceFolder[]): Promise<LangiumDocument[]>;
  /**
   * Load all additional documents that shall be visible in the context of the given workspace
   * folders and add them to the collector. This can be used to include built-in libraries of
   * your language, which can be either loaded from provided files or constructed in memory.
   */
  protected loadAdditionalDocuments(folders: WorkspaceFolder[], collector: (document: LangiumDocument) => void): Promise<void>;
  /**
   * Traverse the file system folder identified by the given URI and its subfolders. All
   * contained files that match the file extensions are added to the collector.
   */
  protected traverseFolder(workspaceFolder: WorkspaceFolder, folderPath: URI, selector: FileSelector, collector: (document: LangiumDocument) => void): Promise<void>;
  /**
   * Determine whether the given folder entry shall be included while indexing the workspace.
   */
  protected includeEntry(_: WorkspaceFolder, entry: FileSystemNode, selector: FileSelector): boolean;
  workspace(): WorkspaceFolder | null;
  rebuildAll(cancelToken?: CancellationToken$1): Promise<void>;
  get workspaceUri(): URI;
  get workspaceURL(): URL;
  /**
   * Force clean all caches
   */
  forceCleanCaches(): void;
  /**
   * Register a listener to be called when caches are force cleaned
   */
  onForceCleanCache(listener: () => void): Disposable$1;
  /**
   * Read workspace exclude patterns from configuration before workspace scan.
   * Uses a timeout fallback for third-party IDEs that may not support workspace/configuration.
   */
  private readExcludeConfig;
} //#endregion
//#region src/references/scope-provider.d.ts
declare class LikeC4ScopeProvider extends DefaultScopeProvider {
  protected deploymentsIndex: DeploymentsIndex;
  protected fqnIndex: FqnIndex;
  protected readonly indexManager: IndexManager;
  constructor(services: LikeC4Services);
  getScope(context: ReferenceInfo): Scope;
  protected genUniqueDescedants(element: Element | DeploymentNode | undefined): Generator<AstNodeDescriptionWithFqn, void, any>;
  protected genScopeExtendElement({
    element
  }: ExtendElement): Generator<AstNodeDescription>;
  protected genScopeElementView({
    viewOf,
    extends: ext
  }: ElementView): Generator<AstNodeDescription>;
  protected getScopeForStrictFqnRef(projectId: ProjectId$1, container: StrictFqnRef, context: ReferenceInfo): Scope;
  protected genScopeExtendDeployment({
    deploymentNode
  }: ExtendDeployment): Generator<AstNodeDescription>;
  protected streamForFqnRef(projectId: ProjectId$1, container: FqnRef$2, context: ReferenceInfo): Stream<AstNodeDescription>;
  protected genScopeForParentlessFqnRef(projectId: ProjectId$1, container: FqnRef$2, context: ReferenceInfo): Generator<AstNodeDescription>;
  /**
   * Computes the scope for a given reference context.
   *
   * @param context - The reference information containing the context for which the scope is being computed.
   * @param referenceType - The type of reference being resolved. Defaults to the reference type derived from the context.
   * @returns A scope containing the relevant AST node descriptions for the given reference context.
   *
   * This method first checks if there are precomputed scopes available in the document. If not, it falls back to the global scope.
   * It then iterates through the container hierarchy, collecting relevant scopes based on the reference type and container type.
   * Finally, it combines the collected scopes with the global scope to produce the final scope.
   */
  protected computeScope(projectId: ProjectId$1, context: ReferenceInfo, referenceType?: string): Generator<AstNodeDescription>;
  /**
   * Create a global scope filtered for the given reference type.
   */
  protected getProjectScope(projectId: ProjectId$1, referenceType: string, context: ReferenceInfo): Scope;
  /**
   * Create a global scope filtered for the given reference type.
   */
  protected getGlobalScope(referenceType: string, context: ReferenceInfo): Scope;
} //#endregion
//#region src/utils/disposable.d.ts
declare abstract class ADisposable implements Disposable$1 {
  protected toDispose: Disposable$1[];
  protected isDisposed: boolean;
  onDispose(...disposable: Disposable$1[]): void;
  dispose(): void;
  protected throwIfDisposed(): void;
} //#endregion
//#region src/model/fqn-index.d.ts
declare class FqnIndex<AstNd = Element> extends ADisposable {
  protected services: LikeC4Services;
  protected projects: ProjectsManager;
  protected langiumDocuments: LangiumDocuments;
  protected documentCache: DefaultWeakMap<LikeC4LangiumDocument, DocumentFqnIndex>;
  protected workspaceCache: WorkspaceCache<string, AstNodeDescriptionWithFqn[]>;
  protected logger: any;
  constructor(services: LikeC4Services);
  private documents;
  get(document: LikeC4LangiumDocument): DocumentFqnIndex;
  resolve(reference: Referenceable): Fqn;
  getFqn(el: AstNd): Fqn;
  byFqn(projectId: ProjectId, fqn: Fqn): Stream<AstNodeDescriptionWithFqn>;
  rootElements(projectId: ProjectId): Stream<AstNodeDescriptionWithFqn>;
  directChildrenOf(projectId: ProjectId, parent: Fqn): Stream<AstNodeDescriptionWithFqn>;
  /**
   * Returns descedant elements with unique names in the scope
   */
  uniqueDescedants(projectId: ProjectId, parent: Fqn): Stream<AstNodeDescriptionWithFqn>;
  protected createDocumentIndex(document: LikeC4LangiumDocument): DocumentFqnIndex;
}
declare class DocumentFqnIndex {
  private _rootElements;
  /**
   * direct children of elements
   */
  private _children;
  /**
   * All descendants of an element (unique by name)
   */
  private _descendants;
  /**
   * All elements by FQN
   */
  private _byfqn;
  readonly projectId: ProjectId;
  static readonly EMPTY: DocumentFqnIndex;
  constructor(_rootElements: Array<AstNodeDescriptionWithFqn>,
  /**
   * direct children of elements
   */

  _children: MultiMap<Fqn, AstNodeDescriptionWithFqn>,
  /**
   * All descendants of an element (unique by name)
   */

  _descendants: MultiMap<Fqn, AstNodeDescriptionWithFqn>,
  /**
   * All elements by FQN
   */

  _byfqn: MultiMap<Fqn, AstNodeDescriptionWithFqn>, projectId: ProjectId);
  rootElements(): readonly AstNodeDescriptionWithFqn[];
  byFqn(fqn: Fqn): readonly AstNodeDescriptionWithFqn[];
  children(parent: Fqn): readonly AstNodeDescriptionWithFqn[];
  descendants(nodeName: Fqn): readonly AstNodeDescriptionWithFqn[];
} //#endregion
//#region src/model/deployments-index.d.ts
declare class DeploymentsIndex extends FqnIndex<DeploymentElement> {
  protected services: LikeC4Services;
  protected Names: LikeC4NameProvider;
  protected logger: any;
  constructor(services: LikeC4Services);
  protected createDocumentIndex(document: LikeC4LangiumDocument): DocumentFqnIndex;
} //#endregion
//#region src/model/builder/MergedSpecification.d.ts
/**
 * The `MergedSpecification` class is responsible for merging multiple parsed
 * LikeC4Langium documents into a single specification. It consolidates tags,
 * elements, deployments, relationships, and colors from the provided documents
 * and provides methods to convert parsed models into C4 model elements and relations.
 */
declare class MergedSpecification {
  readonly specs: Omit<ParsedAstSpecification, 'tags'>;
  readonly tags: Readonly<Record<c4.Tag, c4.TagSpecification>>;
  readonly globals: c4.ModelGlobals;
  readonly imports: MultiMap<c4.ProjectId, c4.Fqn, Set<c4.Fqn>>;
  readonly projectId: c4.ProjectId | undefined;
  readonly inferTechFromIcon: boolean;
  constructor(docs: ReadonlyArray<ParsedLikeC4LangiumDocument>, opts?: {
    inferTechFromIcon?: boolean;
  });
  /**
   * Converts a parsed model into a C4 model element.
   */
  toModelElement: ({
    tags,
    links,
    style,
    id,
    kind,
    title,
    description,
    technology,
    summary,
    metadata
  }: ParsedAstElement) => c4.Element | null;
  /**
   * Converts a parsed model into a C4 model relation.
   */
  toModelRelation: ({
    astPath: _astPath,
    source,
    target,
    kind,
    links,
    id,
    ...model
  }: ParsedAstRelation) => c4.Relationship | null;
  /**
   * Converts a parsed deployment model into a C4 deployment model
   */
  toDeploymentElement: (parsed: ParsedAstDeployment) => c4.DeploymentElement | null;
  /**
   * Converts a parsed deployment relation into a C4 deployment relation.
   */
  toDeploymentRelation: ({
    astPath: _astPath,
    source,
    target,
    kind,
    links,
    id,
    ...model
  }: ParsedAstDeploymentRelation) => c4.DeploymentRelationship | null;
} //#endregion
//#region src/model/last-seen-artifacts.d.ts
/**
 * Provides access to "last seen artifacts" for a given project,
 * (Results of the last successful parsing)
 */
declare class LastSeenArtifacts {
  #private;
  constructor(services: LikeC4Services);
  /**
   * Cache the last successful merged specification for its project.
   * @param specification - MergedSpecification to store (by projectId).
   * @returns The same specification (stores in internal map when projectId is set).
   */
  rememberSpecification(specification: MergedSpecification): MergedSpecification;
  /**
   * Cache the last successful computed model and its styles for the project.
   * @param model - LikeC4Model.Computed to store (by projectId).
   * @returns The same model (stores model and styles in internal maps).
   */
  rememberModel<M extends LikeC4Model.Computed>(model: M): M;
  /**
   * Returns the last seen merged specification for the given project, if available.
   * @param projectId - Project id to look up.
   * @returns MergedSpecification or undefined.
   */
  specification(projectId: c4.ProjectId): MergedSpecification | undefined;
  /**
   * Returns the last seen styles for the given project, if available.
   * @param projectId - Project id to look up.
   * @returns LikeC4Styles or undefined.
   */
  styles(projectId: c4.ProjectId): LikeC4Styles | undefined;
  /**
   * Returns the last seen computed model for the given project, if available.
   * @param projectId - Project id to look up.
   * @returns LikeC4Model.Computed or undefined.
   */
  model(projectId: c4.ProjectId): LikeC4Model.Computed | undefined;
} //#endregion
//#region src/model/model-builder.d.ts
type ModelParsedListener = (projectId: ProjectId$1, docs: URI[]) => void;
interface LikeC4ModelBuilder extends Disposable$1 {
  parseModel(projectId?: ProjectId$1 | undefined, cancelToken?: CancellationToken$1): Promise<LikeC4Model<UnknownParsed> | null>;
  unsafeSyncComputeModel(projectId: ProjectId$1): LikeC4Model<UnknownComputed>;
  computeModel(projectId?: ProjectId$1 | undefined, cancelToken?: CancellationToken$1): Promise<LikeC4Model<UnknownComputed>>;
  onModelParsed(callback: ModelParsedListener): Disposable$1;
  clearCache(): void;
} //#endregion
//#region src/model/model-locator.d.ts
/** Result of locating a view: document, view AST, and view block node. */
type ViewLocateResult = {
  doc: ParsedLikeC4LangiumDocument;
  view: ParsedAstView;
  viewAst: LikeC4View;
};
/**
 * Locates elements, views, and documents in the LikeC4 model by FQN or AST node.
 * Used by LSP features (hover, go-to-definition, document tags, etc.).
 */
declare class LikeC4ModelLocator {
  private services;
  private fqnIndex;
  private deploymentsIndex;
  private langiumDocuments;
  private parser;
  private projects;
  constructor(services: LikeC4Services);
  /**
   * Returns the parsed documents
   */
  private documents;
  /**
   * Get parsed element by AST node or by FQN (and optional projectId).
   * @param args - Either [element AST], [fqn], or [fqn, projectId]
   * @returns { projectId, element, document } or null if not found
   */
  getParsedElement(...args: [Element] | [c4.Fqn] | [c4.Fqn, c4.ProjectId]): null | {
    projectId: c4.ProjectId;
    element: ParsedAstElement;
    document: LangiumDocument;
  };
  private findParsedElementByFqnIn;
  /**
   * Get LSP Location for an element by FQN (and optional projectId).
   * @param fqn - Fully qualified name (may include project prefix)
   * @param projectId - Optional project scope
   * @returns Location or null
   */
  locateElement(fqn: c4.Fqn, projectId?: c4.ProjectId | undefined): Location | null;
  locateDeploymentElement(deploymentFqn: c4.DeploymentFqn, projectId?: c4.ProjectId | undefined): Location | null;
  locateRelation(relationId: c4.RelationId, projectId?: c4.ProjectId): Location | null;
  locateViewAst(viewId: c4.ViewId, projectId?: c4.ProjectId | undefined): null | ViewLocateResult;
  /**
   * Get LSP Location for a view by id (and optional projectId).
   * @param viewId - View id
   * @param projectId - Optional project scope
   * @returns Location or null
   */
  locateView(viewId: c4.ViewId, projectId?: c4.ProjectId): Location | null;
  /**
   * Returns an array of tags with their name, color, range and whether they are defined in the specification or not.
   * If the document is not linked, it will wait until it is linked before locating the tags.
   *
   * If the document does not belong to any project, it will return null.
   */
  locateDocumentTags(documentUri: URI, cancelToken?: CancellationToken$1): Promise<null | Array<{
    name: Tag;
    color: c4.ColorLiteral;
    range: Range;
    isSpecification: boolean;
  }>>;
  locateDynamicViewStep(params: {
    view: c4.ViewId;
    astPath: string;
    projectId?: c4.ProjectId | undefined;
  }): Location | null;
} //#endregion
//#region src/views/LikeC4Views.d.ts
type GraphvizOut = {
  readonly dot: string;
  readonly diagram: LayoutedView$1;
};
type GraphvizSvgOut = {
  readonly id: ViewId$1;
  readonly dot: string;
  readonly svg: string;
};
type LayoutViewParams = {
  viewId: ViewId$1;
  /**
   * Type of layout to apply
   * - 'manual' - applies manual layout if any
   * - 'auto' - returns latest version with drifts from manual layout if any
   * - undefined - returns latest layout as is
   */
  layoutType?: LayoutType | undefined;
  projectId?: ProjectId$1 | undefined;
  cancelToken?: CancellationToken$1 | undefined; /** Optional AI-generated layout hints */
  layoutHints?: AILayoutHints | undefined;
};
interface LikeC4Views {
  readonly layouter: GraphvizLayouter;
  /**
   * Returns computed views (i.e. views with predicates computed)
   *
   * @param projectId - project id, if not specified - uses the default project
   */
  computedViews(projectId?: ProjectId$1 | undefined, cancelToken?: CancellationToken$1): Promise<ComputedView[]>;
  /**
   * Layouts all views (ignoring any manual snapshots)
   *
   * @param projectId - project id, if not specified - uses the default project
   */
  layoutAllViews(projectId?: ProjectId$1 | undefined, cancelToken?: CancellationToken$1): Promise<GraphvizOut[]>;
  /**
   * Layouts a view.
   * If `layoutType` is 'manual' - applies manual layout if any.
   * If `layoutType` is 'auto' - returns latest version with drifts from manual layout if any
   * If not specified - returns latest layout as is
   *
   * If `layoutHints` are provided, they will be used, ignoring any manual snapshots, and the resulting layout will not be cached (i.e. it will be computed on every call)
   *
   * If view not found in model, but there is a snapshot - it will be returned (with empty DOT)
   */
  layoutView(params: LayoutViewParams): Promise<GraphvizOut | null>;
  /**
   * Returns diagrams.
   * If diagram has manual layout, it will be used.
   * @param projectId - project id, if not specified - uses the default project
   */
  diagrams(projectId?: ProjectId$1 | undefined, cancelToken?: CancellationToken$1): Promise<Array<DiagramView>>;
  /**
   * Returns all layouted views as Graphviz output (i.e. views with layout computed)
   * @param projectId - project id, if not specified - uses the default project
   */
  viewsAsGraphvizOut(projectId?: ProjectId$1 | undefined, cancelToken?: CancellationToken$1): Promise<Array<GraphvizSvgOut>>;
  /**
   * Open view in the preview panel.
   * (works only if running as a vscode extension)
   *
   * @param projectId - project id, if not specified - uses the default project
   */
  openView(viewId: ViewId$1, projectId?: ProjectId$1 | undefined): Promise<void>;
  /**
   * Computes and layouts an adhoc view (not defined in the model)
   *
   * @param projectId - project id, if not specified - uses the default project
   */
  adhocView(predicates: AdhocViewPredicate[], projectId?: ProjectId$1 | undefined): Promise<LayoutedView$1>;
} //#endregion
//#region src/views/index.d.ts
//#endregion
//#region src/model/parser/Base.d.ts
type ParserLevel = 'base' | 'model' | 'deployment' | 'fqnref' | 'relation' | 'views' | 'globals' | 'imports' | 'specification';
declare class BaseParser {
  readonly services: LikeC4Services;
  readonly doc: ParsedLikeC4LangiumDocument;
  readonly project: Project;
  isValid: IsValidFn;
  /** Full URI of the document */
  docUri: string;
  /** Path of the document relative to the project root */
  docPathInProject: string;
  constructor(services: LikeC4Services, doc: ParsedLikeC4LangiumDocument, project: Project);
  logError(error: unknown, astNode?: AstNode | Reference<AstNode>, level?: ParserLevel): void;
  tryParse<N extends AstNode, T>(level: ParserLevel, node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
  tryMap<N extends AstNode, T>(level: ParserLevel, iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
  resolveFqn(node: FqnReferenceable): c4.Fqn;
  getAstNodePath(node: AstNode): string;
  getMetadata(metadataAstNode: MetadataProperty | undefined): {
    [key: string]: string | string[];
  } | undefined;
  parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): c4.MarkdownOrString | undefined;
  convertTags<E extends {
    tags?: Tags;
  }>(withTags?: E): any;
  parseTags<E extends {
    tags?: Tags;
  }>(withTags?: E): c4.NonEmptyArray<c4.Tag> | null;
  convertLinks(source?: LinkProperty['$container']): c4.NonEmptyArray<c4.Link> | undefined;
  parseLinks(source?: LinkProperty['$container']): c4.NonEmptyArray<c4.Link> | undefined;
  parseIconProperty(prop: IconProperty | undefined): c4.IconUrl | undefined;
  parseImageAlias(value: string): string | undefined;
  parseColorLiteral(astNode: ColorLiteral$1): c4.ColorLiteral | undefined;
  parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
  parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
  /**
   * Parse base properties: title, description and technology
   *
   * @param props - body properties (inside '{...}')
   * @param override - optional, inline properties (right on the node)
   *                   have higher priority and override body properties
   */
  parseBaseProps(props: {
    title?: MarkdownOrString | undefined;
    summary?: MarkdownOrString | undefined;
    description?: MarkdownOrString | undefined;
    technology?: MarkdownOrString | undefined;
  }, override?: {
    title?: string | undefined;
    summary?: string | undefined;
    description?: string | undefined;
    technology?: string | undefined;
  }): {
    title?: string;
    summary?: c4.MarkdownOrString;
    description?: c4.MarkdownOrString;
    technology?: string;
  };
} //#endregion
//#region src/model/model-parser.d.ts
declare const DocumentParserFromMixins: {
  new (...args: any[]): {
    parseGlobals(): void;
    parseAndStoreGlobalPredicateGroupOrDynamic(astRule: GlobalPredicateGroup | GlobalDynamicPredicateGroup, id: ProjectId$1, c4Globals: ParsedAstGlobals): void;
    parseGlobalPredicateGroup(astRule: GlobalPredicateGroup): ProjectId$1[];
    parseGlobalDynamicPredicateGroup(astRule: GlobalDynamicPredicateGroup): ProjectId$1[];
    parseGlobalStyleOrGroup(astRule: GlobalStyle | GlobalStyleGroup): ProjectId$1[];
    parseViews(): void;
    parseElementView(astNode: ElementView, additionalStyles: any[]): ParsedAstElementView;
    parseElementViewRule(astRule: ViewRule): ProjectId$1;
    parseViewRulePredicate(astNode: ViewRulePredicate): ProjectId$1;
    parseViewRuleGlobalPredicateRef(astRule: ViewRuleGlobalPredicateRef | DynamicViewGlobalPredicateRef): ProjectId$1;
    parseViewRuleStyleOrGlobalRef(astRule: ViewRuleStyleOrGlobalRef): any;
    parseViewRuleGroup(astNode: ViewRuleGroup): ProjectId$1;
    parseViewRuleRank(astRule: ViewRuleRank): ProjectId$1;
    parseViewRuleStyle(astRule: ViewRuleStyle | GlobalStyle): ProjectId$1;
    parseViewRuleGlobalStyle(astRule: ViewRuleGlobalStyle): ProjectId$1;
    parseDynamicElementView(astNode: DynamicView, additionalStyles: any[]): ParsedAstDynamicView;
    parseDynamicViewRule(astRule: DynamicViewRule): ProjectId$1;
    parseDynamicViewIncludePredicate(astRule: DynamicViewIncludePredicate): ProjectId$1;
    parseDynamicParallelSteps(node: DynamicViewParallelSteps): ProjectId$1;
    parseDynamicStep(node: DynamicViewStep): ProjectId$1 | ProjectId$1;
    recursiveParseDynamicStepChain(node: DynamicStepChain, callstack?: Array<[source: ProjectId$1, target: ProjectId$1]>): ProjectId$1[];
    parseDynamicStepSingle(node: DynamicStepSingle): ProjectId$1;
    parseAbstractDynamicStep(astnode: AbstractDynamicStep): type_fest0.Writable<type_fest0.Except<ProjectId$1, "source", {
      requireExactProps: true;
    }>>;
    parsePredicate(astNode: ExpressionV2): ProjectId$1;
    parseElementPredicate(astNode: FqnExprOrWith): ProjectId$1;
    parseElementPredicateOrWhere(astNode: FqnExprOrWhere): ProjectId$1;
    parseElementExpression(astNode: FqnExpr$2): ProjectId$1;
    parseElementPredicateWhere(astNode: FqnExprWhere): ProjectId$1;
    parseElementPredicateWith(astNode: FqnExprWith): ProjectId$1;
    parseRelationPredicate(astNode: RelationExprOrWith): ProjectId$1;
    parseRelationPredicateOrWhere(astNode: RelationExprOrWhere): ProjectId$1;
    parseRelationPredicateWhere(astNode: RelationExprWhere): ProjectId$1;
    parseRelationPredicateWith(astNode: RelationExprWith): ProjectId$1;
    parseRelationExpression(astNode: RelationExpr$1): ProjectId$1;
    parseFqnRef(astNode: FqnRef$2): ProjectId$1;
    parseExpressionV2(astNode: ExpressionV2): ProjectId$1;
    parseFqnExprOrWith(astNode: FqnExprOrWith): ProjectId$1;
    parseFqnExprWith(astNode: FqnExprWith): ProjectId$1;
    parseFqnExprOrWhere(astNode: FqnExprOrWhere): ProjectId$1;
    parseFqnExprWhere(astNode: FqnExprWhere): ProjectId$1;
    parseFqnExpr(astNode: FqnExpr$2): ProjectId$1;
    parseFqnRefExpr(astNode: FqnRefExpr): ProjectId$1;
    parseFqnExpressions(astNode: FqnExpressions): ProjectId$1[];
    parseRelationExprOrWith(astNode: RelationExprOrWith): ProjectId$1;
    parseRelationExprWith(astNode: RelationExprWith): ProjectId$1;
    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): type_fest0.Except<ProjectId$1["customRelation"], "expr">;
    parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId$1;
    parseRelationExprWhere(astNode: RelationExprWhere): ProjectId$1;
    parseRelationExpr(astNode: RelationExpr$1): ProjectId$1;
    parseInlineKindCondition(astNode: OutgoingRelationExpr): ProjectId$1 | null;
    wrapInWhere(expr: ProjectId$1, condition: ProjectId$1 | null): ProjectId$1;
    isValid: IsValidFn;
    docUri: string;
    docPathInProject: string;
    readonly services: LikeC4Services;
    readonly doc: ParsedLikeC4LangiumDocument;
    readonly project: Project;
    logError(error: unknown, astNode?: AstNode | Reference<AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
    tryParse<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
    resolveFqn(node: FqnReferenceable): ProjectId$1;
    getAstNodePath(node: AstNode): string;
    getMetadata(metadataAstNode: MetadataProperty | undefined): {
      [key: string]: string | string[];
    } | undefined;
    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId$1 | undefined;
    convertTags<E extends {
      tags?: Tags;
    }>(withTags?: E | undefined): any;
    parseTags<E extends {
      tags?: Tags;
    }>(withTags?: E): ProjectId$1<ProjectId$1> | null;
    convertLinks(source?: LinkProperty["$container"]): ProjectId$1<ProjectId$1> | undefined;
    parseLinks(source?: LinkProperty["$container"]): ProjectId$1<ProjectId$1> | undefined;
    parseIconProperty(prop: IconProperty | undefined): ProjectId$1 | undefined;
    parseImageAlias(value: string): string | undefined;
    parseColorLiteral(astNode: ColorLiteral$1): ProjectId$1 | undefined;
    parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
    parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
    parseBaseProps(props: {
      title?: MarkdownOrString | undefined;
      summary?: MarkdownOrString | undefined;
      description?: MarkdownOrString | undefined;
      technology?: MarkdownOrString | undefined;
    }, override?: {
      title?: string | undefined;
      summary?: string | undefined;
      description?: string | undefined;
      technology?: string | undefined;
    }): {
      title?: string;
      summary?: ProjectId$1;
      description?: ProjectId$1;
      technology?: string;
    };
    parseDeploymentView(astNode: DeploymentView): ParsedAstDeploymentView;
    parseDeploymentViewRule(astRule: DeploymentViewRule): ProjectId$1;
    parseDeploymentViewRulePredicate(astRule: DeploymentViewRulePredicate): ProjectId$1;
    parseDeploymentViewRuleStyle(astRule: DeploymentViewRuleStyle): ProjectId$1;
    parseDeployment(): void;
    parseDeploymentNode(astNode: DeploymentNode): ParsedAstDeployment.Node;
    parseDeployedInstance(astNode: DeployedInstance): ParsedAstDeployment.Instance;
    parseExtendDeployment(astNode: ExtendDeployment): ParsedAstExtend | null;
    _resolveDeploymentRelationSource(node: DeploymentRelation): ProjectId$1;
    parseDeploymentRelation(astNode: DeploymentRelation): ParsedAstDeploymentRelation;
  };
} & {
  new (...args: any[]): {
    parseViews(): void;
    parseElementView(astNode: ElementView, additionalStyles: any[]): ParsedAstElementView;
    parseElementViewRule(astRule: ViewRule): ProjectId$1;
    parseViewRulePredicate(astNode: ViewRulePredicate): ProjectId$1;
    parseViewRuleGlobalPredicateRef(astRule: ViewRuleGlobalPredicateRef | DynamicViewGlobalPredicateRef): ProjectId$1;
    parseViewRuleStyleOrGlobalRef(astRule: ViewRuleStyleOrGlobalRef): any;
    parseViewRuleGroup(astNode: ViewRuleGroup): ProjectId$1;
    parseViewRuleRank(astRule: ViewRuleRank): ProjectId$1;
    parseViewRuleStyle(astRule: ViewRuleStyle | GlobalStyle): ProjectId$1;
    parseViewRuleGlobalStyle(astRule: ViewRuleGlobalStyle): ProjectId$1;
    parseDynamicElementView(astNode: DynamicView, additionalStyles: any[]): ParsedAstDynamicView;
    parseDynamicViewRule(astRule: DynamicViewRule): ProjectId$1;
    parseDynamicViewIncludePredicate(astRule: DynamicViewIncludePredicate): ProjectId$1;
    parseDynamicParallelSteps(node: DynamicViewParallelSteps): ProjectId$1;
    parseDynamicStep(node: DynamicViewStep): ProjectId$1 | ProjectId$1;
    recursiveParseDynamicStepChain(node: DynamicStepChain, callstack?: Array<[source: ProjectId$1, target: ProjectId$1]>): ProjectId$1[];
    parseDynamicStepSingle(node: DynamicStepSingle): ProjectId$1;
    parseAbstractDynamicStep(astnode: AbstractDynamicStep): type_fest0.Writable<type_fest0.Except<ProjectId$1, "source", {
      requireExactProps: true;
    }>>;
    parsePredicate(astNode: ExpressionV2): ProjectId$1;
    parseElementPredicate(astNode: FqnExprOrWith): ProjectId$1;
    parseElementPredicateOrWhere(astNode: FqnExprOrWhere): ProjectId$1;
    parseElementExpression(astNode: FqnExpr$2): ProjectId$1;
    parseElementPredicateWhere(astNode: FqnExprWhere): ProjectId$1;
    parseElementPredicateWith(astNode: FqnExprWith): ProjectId$1;
    parseRelationPredicate(astNode: RelationExprOrWith): ProjectId$1;
    parseRelationPredicateOrWhere(astNode: RelationExprOrWhere): ProjectId$1;
    parseRelationPredicateWhere(astNode: RelationExprWhere): ProjectId$1;
    parseRelationPredicateWith(astNode: RelationExprWith): ProjectId$1;
    parseRelationExpression(astNode: RelationExpr$1): ProjectId$1;
    parseFqnRef(astNode: FqnRef$2): ProjectId$1;
    parseExpressionV2(astNode: ExpressionV2): ProjectId$1;
    parseFqnExprOrWith(astNode: FqnExprOrWith): ProjectId$1;
    parseFqnExprWith(astNode: FqnExprWith): ProjectId$1;
    parseFqnExprOrWhere(astNode: FqnExprOrWhere): ProjectId$1;
    parseFqnExprWhere(astNode: FqnExprWhere): ProjectId$1;
    parseFqnExpr(astNode: FqnExpr$2): ProjectId$1;
    parseFqnRefExpr(astNode: FqnRefExpr): ProjectId$1;
    parseFqnExpressions(astNode: FqnExpressions): ProjectId$1[];
    parseRelationExprOrWith(astNode: RelationExprOrWith): ProjectId$1;
    parseRelationExprWith(astNode: RelationExprWith): ProjectId$1;
    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): type_fest0.Except<ProjectId$1["customRelation"], "expr">;
    parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId$1;
    parseRelationExprWhere(astNode: RelationExprWhere): ProjectId$1;
    parseRelationExpr(astNode: RelationExpr$1): ProjectId$1;
    parseInlineKindCondition(astNode: OutgoingRelationExpr): ProjectId$1 | null;
    wrapInWhere(expr: ProjectId$1, condition: ProjectId$1 | null): ProjectId$1;
    isValid: IsValidFn;
    docUri: string;
    docPathInProject: string;
    readonly services: LikeC4Services;
    readonly doc: ParsedLikeC4LangiumDocument;
    readonly project: Project;
    logError(error: unknown, astNode?: AstNode | Reference<AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
    tryParse<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
    resolveFqn(node: FqnReferenceable): ProjectId$1;
    getAstNodePath(node: AstNode): string;
    getMetadata(metadataAstNode: MetadataProperty | undefined): {
      [key: string]: string | string[];
    } | undefined;
    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId$1 | undefined;
    convertTags<E extends {
      tags?: Tags;
    }>(withTags?: E | undefined): any;
    parseTags<E extends {
      tags?: Tags;
    }>(withTags?: E): ProjectId$1<ProjectId$1> | null;
    convertLinks(source?: LinkProperty["$container"]): ProjectId$1<ProjectId$1> | undefined;
    parseLinks(source?: LinkProperty["$container"]): ProjectId$1<ProjectId$1> | undefined;
    parseIconProperty(prop: IconProperty | undefined): ProjectId$1 | undefined;
    parseImageAlias(value: string): string | undefined;
    parseColorLiteral(astNode: ColorLiteral$1): ProjectId$1 | undefined;
    parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
    parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
    parseBaseProps(props: {
      title?: MarkdownOrString | undefined;
      summary?: MarkdownOrString | undefined;
      description?: MarkdownOrString | undefined;
      technology?: MarkdownOrString | undefined;
    }, override?: {
      title?: string | undefined;
      summary?: string | undefined;
      description?: string | undefined;
      technology?: string | undefined;
    }): {
      title?: string;
      summary?: ProjectId$1;
      description?: ProjectId$1;
      technology?: string;
    };
    parseDeploymentView(astNode: DeploymentView): ParsedAstDeploymentView;
    parseDeploymentViewRule(astRule: DeploymentViewRule): ProjectId$1;
    parseDeploymentViewRulePredicate(astRule: DeploymentViewRulePredicate): ProjectId$1;
    parseDeploymentViewRuleStyle(astRule: DeploymentViewRuleStyle): ProjectId$1;
    parseDeployment(): void;
    parseDeploymentNode(astNode: DeploymentNode): ParsedAstDeployment.Node;
    parseDeployedInstance(astNode: DeployedInstance): ParsedAstDeployment.Instance;
    parseExtendDeployment(astNode: ExtendDeployment): ParsedAstExtend | null;
    _resolveDeploymentRelationSource(node: DeploymentRelation): ProjectId$1;
    parseDeploymentRelation(astNode: DeploymentRelation): ParsedAstDeploymentRelation;
  };
} & {
  new (...args: any[]): {
    parseSpecification(): void;
    parseElementSpecificationNode(specAst: SpecificationElementKind): {};
    parseElementSpecificationNode(specAst: SpecificationDeploymentNodeKind): {};
    isValid: IsValidFn;
    docUri: string;
    docPathInProject: string;
    readonly services: LikeC4Services;
    readonly doc: ParsedLikeC4LangiumDocument;
    readonly project: Project;
    logError(error: unknown, astNode?: AstNode | Reference<AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
    tryParse<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
    resolveFqn(node: FqnReferenceable): ProjectId$1;
    getAstNodePath(node: AstNode): string;
    getMetadata(metadataAstNode: MetadataProperty | undefined): {
      [key: string]: string | string[];
    } | undefined;
    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId$1 | undefined;
    convertTags<E extends {
      tags?: Tags;
    }>(withTags?: E | undefined): any;
    parseTags<E extends {
      tags?: Tags;
    }>(withTags?: E): ProjectId$1<ProjectId$1> | null;
    convertLinks(source?: LinkProperty["$container"]): ProjectId$1<ProjectId$1> | undefined;
    parseLinks(source?: LinkProperty["$container"]): ProjectId$1<ProjectId$1> | undefined;
    parseIconProperty(prop: IconProperty | undefined): ProjectId$1 | undefined;
    parseImageAlias(value: string): string | undefined;
    parseColorLiteral(astNode: ColorLiteral$1): ProjectId$1 | undefined;
    parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
    parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
    parseBaseProps(props: {
      title?: MarkdownOrString | undefined;
      summary?: MarkdownOrString | undefined;
      description?: MarkdownOrString | undefined;
      technology?: MarkdownOrString | undefined;
    }, override?: {
      title?: string | undefined;
      summary?: string | undefined;
      description?: string | undefined;
      technology?: string | undefined;
    }): {
      title?: string;
      summary?: ProjectId$1;
      description?: ProjectId$1;
      technology?: string;
    };
  };
} & {
  new (...args: any[]): {
    parsePredicate(astNode: ExpressionV2): ProjectId$1;
    parseElementPredicate(astNode: FqnExprOrWith): ProjectId$1;
    parseElementPredicateOrWhere(astNode: FqnExprOrWhere): ProjectId$1;
    parseElementExpression(astNode: FqnExpr$2): ProjectId$1;
    parseElementPredicateWhere(astNode: FqnExprWhere): ProjectId$1;
    parseElementPredicateWith(astNode: FqnExprWith): ProjectId$1;
    parseRelationPredicate(astNode: RelationExprOrWith): ProjectId$1;
    parseRelationPredicateOrWhere(astNode: RelationExprOrWhere): ProjectId$1;
    parseRelationPredicateWhere(astNode: RelationExprWhere): ProjectId$1;
    parseRelationPredicateWith(astNode: RelationExprWith): ProjectId$1;
    parseRelationExpression(astNode: RelationExpr$1): ProjectId$1;
    parseFqnRef(astNode: FqnRef$2): ProjectId$1;
    parseExpressionV2(astNode: ExpressionV2): ProjectId$1;
    parseFqnExprOrWith(astNode: FqnExprOrWith): ProjectId$1;
    parseFqnExprWith(astNode: FqnExprWith): ProjectId$1;
    parseFqnExprOrWhere(astNode: FqnExprOrWhere): ProjectId$1;
    parseFqnExprWhere(astNode: FqnExprWhere): ProjectId$1;
    parseFqnExpr(astNode: FqnExpr$2): ProjectId$1;
    parseFqnRefExpr(astNode: FqnRefExpr): ProjectId$1;
    parseFqnExpressions(astNode: FqnExpressions): ProjectId$1[];
    parseRelationExprOrWith(astNode: RelationExprOrWith): ProjectId$1;
    parseRelationExprWith(astNode: RelationExprWith): ProjectId$1;
    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): type_fest0.Except<ProjectId$1["customRelation"], "expr">;
    parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId$1;
    parseRelationExprWhere(astNode: RelationExprWhere): ProjectId$1;
    parseRelationExpr(astNode: RelationExpr$1): ProjectId$1;
    parseInlineKindCondition(astNode: OutgoingRelationExpr): ProjectId$1 | null;
    wrapInWhere(expr: ProjectId$1, condition: ProjectId$1 | null): ProjectId$1;
    isValid: IsValidFn;
    docUri: string;
    docPathInProject: string;
    readonly services: LikeC4Services;
    readonly doc: ParsedLikeC4LangiumDocument;
    readonly project: Project;
    logError(error: unknown, astNode?: AstNode | Reference<AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
    tryParse<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
    resolveFqn(node: FqnReferenceable): ProjectId$1;
    getAstNodePath(node: AstNode): string;
    getMetadata(metadataAstNode: MetadataProperty | undefined): {
      [key: string]: string | string[];
    } | undefined;
    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId$1 | undefined;
    convertTags<E extends {
      tags?: Tags;
    }>(withTags?: E | undefined): any;
    parseTags<E extends {
      tags?: Tags;
    }>(withTags?: E): ProjectId$1<ProjectId$1> | null;
    convertLinks(source?: LinkProperty["$container"]): ProjectId$1<ProjectId$1> | undefined;
    parseLinks(source?: LinkProperty["$container"]): ProjectId$1<ProjectId$1> | undefined;
    parseIconProperty(prop: IconProperty | undefined): ProjectId$1 | undefined;
    parseImageAlias(value: string): string | undefined;
    parseColorLiteral(astNode: ColorLiteral$1): ProjectId$1 | undefined;
    parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
    parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
    parseBaseProps(props: {
      title?: MarkdownOrString | undefined;
      summary?: MarkdownOrString | undefined;
      description?: MarkdownOrString | undefined;
      technology?: MarkdownOrString | undefined;
    }, override?: {
      title?: string | undefined;
      summary?: string | undefined;
      description?: string | undefined;
      technology?: string | undefined;
    }): {
      title?: string;
      summary?: ProjectId$1;
      description?: ProjectId$1;
      technology?: string;
    };
  };
} & {
  new (...args: any[]): {
    parseDeploymentView(astNode: DeploymentView): ParsedAstDeploymentView;
    parseDeploymentViewRule(astRule: DeploymentViewRule): ProjectId$1;
    parseDeploymentViewRulePredicate(astRule: DeploymentViewRulePredicate): ProjectId$1;
    parseDeploymentViewRuleStyle(astRule: DeploymentViewRuleStyle): ProjectId$1;
    parseFqnRef(astNode: FqnRef$2): ProjectId$1;
    parseExpressionV2(astNode: ExpressionV2): ProjectId$1;
    parseFqnExprOrWith(astNode: FqnExprOrWith): ProjectId$1;
    parseFqnExprWith(astNode: FqnExprWith): ProjectId$1;
    parseFqnExprOrWhere(astNode: FqnExprOrWhere): ProjectId$1;
    parseFqnExprWhere(astNode: FqnExprWhere): ProjectId$1;
    parseFqnExpr(astNode: FqnExpr$2): ProjectId$1;
    parseFqnRefExpr(astNode: FqnRefExpr): ProjectId$1;
    parseFqnExpressions(astNode: FqnExpressions): ProjectId$1[];
    parseRelationExprOrWith(astNode: RelationExprOrWith): ProjectId$1;
    parseRelationExprWith(astNode: RelationExprWith): ProjectId$1;
    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): type_fest0.Except<ProjectId$1["customRelation"], "expr">;
    parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId$1;
    parseRelationExprWhere(astNode: RelationExprWhere): ProjectId$1;
    parseRelationExpr(astNode: RelationExpr$1): ProjectId$1;
    parseInlineKindCondition(astNode: OutgoingRelationExpr): ProjectId$1 | null;
    wrapInWhere(expr: ProjectId$1, condition: ProjectId$1 | null): ProjectId$1;
    isValid: IsValidFn;
    docUri: string;
    docPathInProject: string;
    readonly services: LikeC4Services;
    readonly doc: ParsedLikeC4LangiumDocument;
    readonly project: Project;
    logError(error: unknown, astNode?: AstNode | Reference<AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
    tryParse<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
    resolveFqn(node: FqnReferenceable): ProjectId$1;
    getAstNodePath(node: AstNode): string;
    getMetadata(metadataAstNode: MetadataProperty | undefined): {
      [key: string]: string | string[];
    } | undefined;
    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId$1 | undefined;
    convertTags<E extends {
      tags?: Tags;
    }>(withTags?: E | undefined): any;
    parseTags<E extends {
      tags?: Tags;
    }>(withTags?: E): ProjectId$1<ProjectId$1> | null;
    convertLinks(source?: LinkProperty["$container"]): ProjectId$1<ProjectId$1> | undefined;
    parseLinks(source?: LinkProperty["$container"]): ProjectId$1<ProjectId$1> | undefined;
    parseIconProperty(prop: IconProperty | undefined): ProjectId$1 | undefined;
    parseImageAlias(value: string): string | undefined;
    parseColorLiteral(astNode: ColorLiteral$1): ProjectId$1 | undefined;
    parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
    parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
    parseBaseProps(props: {
      title?: MarkdownOrString | undefined;
      summary?: MarkdownOrString | undefined;
      description?: MarkdownOrString | undefined;
      technology?: MarkdownOrString | undefined;
    }, override?: {
      title?: string | undefined;
      summary?: string | undefined;
      description?: string | undefined;
      technology?: string | undefined;
    }): {
      title?: string;
      summary?: ProjectId$1;
      description?: ProjectId$1;
      technology?: string;
    };
    parseDeployment(): void;
    parseDeploymentNode(astNode: DeploymentNode): ParsedAstDeployment.Node;
    parseDeployedInstance(astNode: DeployedInstance): ParsedAstDeployment.Instance;
    parseExtendDeployment(astNode: ExtendDeployment): ParsedAstExtend | null;
    _resolveDeploymentRelationSource(node: DeploymentRelation): ProjectId$1;
    parseDeploymentRelation(astNode: DeploymentRelation): ParsedAstDeploymentRelation;
  };
} & {
  new (...args: any[]): {
    parseDeployment(): void;
    parseDeploymentNode(astNode: DeploymentNode): ParsedAstDeployment.Node;
    parseDeployedInstance(astNode: DeployedInstance): ParsedAstDeployment.Instance;
    parseExtendDeployment(astNode: ExtendDeployment): ParsedAstExtend | null;
    _resolveDeploymentRelationSource(node: DeploymentRelation): ProjectId$1;
    parseDeploymentRelation(astNode: DeploymentRelation): ParsedAstDeploymentRelation;
    parseFqnRef(astNode: FqnRef$2): ProjectId$1;
    parseExpressionV2(astNode: ExpressionV2): ProjectId$1;
    parseFqnExprOrWith(astNode: FqnExprOrWith): ProjectId$1;
    parseFqnExprWith(astNode: FqnExprWith): ProjectId$1;
    parseFqnExprOrWhere(astNode: FqnExprOrWhere): ProjectId$1;
    parseFqnExprWhere(astNode: FqnExprWhere): ProjectId$1;
    parseFqnExpr(astNode: FqnExpr$2): ProjectId$1;
    parseFqnRefExpr(astNode: FqnRefExpr): ProjectId$1;
    parseFqnExpressions(astNode: FqnExpressions): ProjectId$1[];
    parseRelationExprOrWith(astNode: RelationExprOrWith): ProjectId$1;
    parseRelationExprWith(astNode: RelationExprWith): ProjectId$1;
    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): type_fest0.Except<ProjectId$1["customRelation"], "expr">;
    parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId$1;
    parseRelationExprWhere(astNode: RelationExprWhere): ProjectId$1;
    parseRelationExpr(astNode: RelationExpr$1): ProjectId$1;
    parseInlineKindCondition(astNode: OutgoingRelationExpr): ProjectId$1 | null;
    wrapInWhere(expr: ProjectId$1, condition: ProjectId$1 | null): ProjectId$1;
    isValid: IsValidFn;
    docUri: string;
    docPathInProject: string;
    readonly services: LikeC4Services;
    readonly doc: ParsedLikeC4LangiumDocument;
    readonly project: Project;
    logError(error: unknown, astNode?: AstNode | Reference<AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
    tryParse<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
    resolveFqn(node: FqnReferenceable): ProjectId$1;
    getAstNodePath(node: AstNode): string;
    getMetadata(metadataAstNode: MetadataProperty | undefined): {
      [key: string]: string | string[];
    } | undefined;
    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId$1 | undefined;
    convertTags<E extends {
      tags?: Tags;
    }>(withTags?: E | undefined): any;
    parseTags<E extends {
      tags?: Tags;
    }>(withTags?: E): ProjectId$1<ProjectId$1> | null;
    convertLinks(source?: LinkProperty["$container"]): ProjectId$1<ProjectId$1> | undefined;
    parseLinks(source?: LinkProperty["$container"]): ProjectId$1<ProjectId$1> | undefined;
    parseIconProperty(prop: IconProperty | undefined): ProjectId$1 | undefined;
    parseImageAlias(value: string): string | undefined;
    parseColorLiteral(astNode: ColorLiteral$1): ProjectId$1 | undefined;
    parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
    parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
    parseBaseProps(props: {
      title?: MarkdownOrString | undefined;
      summary?: MarkdownOrString | undefined;
      description?: MarkdownOrString | undefined;
      technology?: MarkdownOrString | undefined;
    }, override?: {
      title?: string | undefined;
      summary?: string | undefined;
      description?: string | undefined;
      technology?: string | undefined;
    }): {
      title?: string;
      summary?: ProjectId$1;
      description?: ProjectId$1;
      technology?: string;
    };
  };
} & {
  new (...args: any[]): {
    parseModel(): void;
    parseElement(astNode: Element): ParsedAstElement;
    parseExtendElement(astNode: ExtendElement): ParsedAstExtend | null;
    parseExtendRelation(astNode: ExtendRelation): ParsedAstExtendRelation | null;
    _resolveRelationSource(node: Relation): ProjectId$1 | ProjectId$1;
    parseRelation(astNode: Relation): ParsedAstRelation;
    parseFqnRef(astNode: FqnRef$2): ProjectId$1;
    parseExpressionV2(astNode: ExpressionV2): ProjectId$1;
    parseFqnExprOrWith(astNode: FqnExprOrWith): ProjectId$1;
    parseFqnExprWith(astNode: FqnExprWith): ProjectId$1;
    parseFqnExprOrWhere(astNode: FqnExprOrWhere): ProjectId$1;
    parseFqnExprWhere(astNode: FqnExprWhere): ProjectId$1;
    parseFqnExpr(astNode: FqnExpr$2): ProjectId$1;
    parseFqnRefExpr(astNode: FqnRefExpr): ProjectId$1;
    parseFqnExpressions(astNode: FqnExpressions): ProjectId$1[];
    parseRelationExprOrWith(astNode: RelationExprOrWith): ProjectId$1;
    parseRelationExprWith(astNode: RelationExprWith): ProjectId$1;
    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): type_fest0.Except<ProjectId$1["customRelation"], "expr">;
    parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId$1;
    parseRelationExprWhere(astNode: RelationExprWhere): ProjectId$1;
    parseRelationExpr(astNode: RelationExpr$1): ProjectId$1;
    parseInlineKindCondition(astNode: OutgoingRelationExpr): ProjectId$1 | null;
    wrapInWhere(expr: ProjectId$1, condition: ProjectId$1 | null): ProjectId$1;
    isValid: IsValidFn;
    docUri: string;
    docPathInProject: string;
    readonly services: LikeC4Services;
    readonly doc: ParsedLikeC4LangiumDocument;
    readonly project: Project;
    logError(error: unknown, astNode?: AstNode | Reference<AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
    tryParse<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
    resolveFqn(node: FqnReferenceable): ProjectId$1;
    getAstNodePath(node: AstNode): string;
    getMetadata(metadataAstNode: MetadataProperty | undefined): {
      [key: string]: string | string[];
    } | undefined;
    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId$1 | undefined;
    convertTags<E extends {
      tags?: Tags;
    }>(withTags?: E | undefined): any;
    parseTags<E extends {
      tags?: Tags;
    }>(withTags?: E): ProjectId$1<ProjectId$1> | null;
    convertLinks(source?: LinkProperty["$container"]): ProjectId$1<ProjectId$1> | undefined;
    parseLinks(source?: LinkProperty["$container"]): ProjectId$1<ProjectId$1> | undefined;
    parseIconProperty(prop: IconProperty | undefined): ProjectId$1 | undefined;
    parseImageAlias(value: string): string | undefined;
    parseColorLiteral(astNode: ColorLiteral$1): ProjectId$1 | undefined;
    parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
    parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
    parseBaseProps(props: {
      title?: MarkdownOrString | undefined;
      summary?: MarkdownOrString | undefined;
      description?: MarkdownOrString | undefined;
      technology?: MarkdownOrString | undefined;
    }, override?: {
      title?: string | undefined;
      summary?: string | undefined;
      description?: string | undefined;
      technology?: string | undefined;
    }): {
      title?: string;
      summary?: ProjectId$1;
      description?: ProjectId$1;
      technology?: string;
    };
  };
} & {
  new (...args: any[]): {
    parseImports(): void;
    isValid: IsValidFn;
    docUri: string;
    docPathInProject: string;
    readonly services: LikeC4Services;
    readonly doc: ParsedLikeC4LangiumDocument;
    readonly project: Project;
    logError(error: unknown, astNode?: AstNode | Reference<AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
    tryParse<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
    resolveFqn(node: FqnReferenceable): ProjectId$1;
    getAstNodePath(node: AstNode): string;
    getMetadata(metadataAstNode: MetadataProperty | undefined): {
      [key: string]: string | string[];
    } | undefined;
    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId$1 | undefined;
    convertTags<E extends {
      tags?: Tags;
    }>(withTags?: E | undefined): any;
    parseTags<E extends {
      tags?: Tags;
    }>(withTags?: E): ProjectId$1<ProjectId$1> | null;
    convertLinks(source?: LinkProperty["$container"]): ProjectId$1<ProjectId$1> | undefined;
    parseLinks(source?: LinkProperty["$container"]): ProjectId$1<ProjectId$1> | undefined;
    parseIconProperty(prop: IconProperty | undefined): ProjectId$1 | undefined;
    parseImageAlias(value: string): string | undefined;
    parseColorLiteral(astNode: ColorLiteral$1): ProjectId$1 | undefined;
    parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
    parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
    parseBaseProps(props: {
      title?: MarkdownOrString | undefined;
      summary?: MarkdownOrString | undefined;
      description?: MarkdownOrString | undefined;
      technology?: MarkdownOrString | undefined;
    }, override?: {
      title?: string | undefined;
      summary?: string | undefined;
      description?: string | undefined;
      technology?: string | undefined;
    }): {
      title?: string;
      summary?: ProjectId$1;
      description?: ProjectId$1;
      technology?: string;
    };
  };
} & {
  new (...args: any[]): {
    parseFqnRef(astNode: FqnRef$2): ProjectId$1;
    parseExpressionV2(astNode: ExpressionV2): ProjectId$1;
    parseFqnExprOrWith(astNode: FqnExprOrWith): ProjectId$1;
    parseFqnExprWith(astNode: FqnExprWith): ProjectId$1;
    parseFqnExprOrWhere(astNode: FqnExprOrWhere): ProjectId$1;
    parseFqnExprWhere(astNode: FqnExprWhere): ProjectId$1;
    parseFqnExpr(astNode: FqnExpr$2): ProjectId$1;
    parseFqnRefExpr(astNode: FqnRefExpr): ProjectId$1;
    parseFqnExpressions(astNode: FqnExpressions): ProjectId$1[];
    parseRelationExprOrWith(astNode: RelationExprOrWith): ProjectId$1;
    parseRelationExprWith(astNode: RelationExprWith): ProjectId$1;
    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): type_fest0.Except<ProjectId$1["customRelation"], "expr">;
    parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId$1;
    parseRelationExprWhere(astNode: RelationExprWhere): ProjectId$1;
    parseRelationExpr(astNode: RelationExpr$1): ProjectId$1;
    parseInlineKindCondition(astNode: OutgoingRelationExpr): ProjectId$1 | null;
    wrapInWhere(expr: ProjectId$1, condition: ProjectId$1 | null): ProjectId$1;
    isValid: IsValidFn;
    docUri: string;
    docPathInProject: string;
    readonly services: LikeC4Services;
    readonly doc: ParsedLikeC4LangiumDocument;
    readonly project: Project;
    logError(error: unknown, astNode?: AstNode | Reference<AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
    tryParse<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
    resolveFqn(node: FqnReferenceable): ProjectId$1;
    getAstNodePath(node: AstNode): string;
    getMetadata(metadataAstNode: MetadataProperty | undefined): {
      [key: string]: string | string[];
    } | undefined;
    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId$1 | undefined;
    convertTags<E extends {
      tags?: Tags;
    }>(withTags?: E | undefined): any;
    parseTags<E extends {
      tags?: Tags;
    }>(withTags?: E): ProjectId$1<ProjectId$1> | null;
    convertLinks(source?: LinkProperty["$container"]): ProjectId$1<ProjectId$1> | undefined;
    parseLinks(source?: LinkProperty["$container"]): ProjectId$1<ProjectId$1> | undefined;
    parseIconProperty(prop: IconProperty | undefined): ProjectId$1 | undefined;
    parseImageAlias(value: string): string | undefined;
    parseColorLiteral(astNode: ColorLiteral$1): ProjectId$1 | undefined;
    parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
    parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
    parseBaseProps(props: {
      title?: MarkdownOrString | undefined;
      summary?: MarkdownOrString | undefined;
      description?: MarkdownOrString | undefined;
      technology?: MarkdownOrString | undefined;
    }, override?: {
      title?: string | undefined;
      summary?: string | undefined;
      description?: string | undefined;
      technology?: string | undefined;
    }): {
      title?: string;
      summary?: ProjectId$1;
      description?: ProjectId$1;
      technology?: string;
    };
  };
} & typeof BaseParser;
declare class DocumentParser extends DocumentParserFromMixins {}
declare class LikeC4ModelParser {
  private services;
  protected cachedParsers: any;
  constructor(services: LikeC4Services);
  documents(projectId: ProjectId$1): Stream<ParsedLikeC4LangiumDocument>;
  parse(doc: LangiumDocument): ParsedLikeC4LangiumDocument;
  forDocument(doc: LangiumDocument): DocumentParser;
  private createParser;
} //#endregion
//#region src/model/parser/ValueConverter.d.ts
declare class LikeC4ValueConverter extends DefaultValueConverter {
  protected runConverter(rule: any, input: string, cstNode: CstNode): ValueType;
} //#endregion
//#region src/model-change/ModelChanges.d.ts
declare class LikeC4ModelChanges {
  private services;
  private locator;
  constructor(services: LikeC4Services);
  applyChange(changeView: ChangeView.Params): Promise<ChangeView.Res>;
  protected convertToTextEdit({
    lookup,
    change
  }: {
    lookup: ViewLocateResult;
    change: Exclude<ViewChange, ViewChange.SaveViewSnapshot | ViewChange.ResetManualLayout | ViewChange.ChangeProperty>;
  }): {
    modifiedRange: Range;
    edits: TextEdit[];
  };
  protected applyTextEdits(doc: ParsedLikeC4LangiumDocument, edits: TextEdit[]): Promise<boolean>;
} //#endregion
//#region src/LikeC4LanguageServices.d.ts
interface LikeC4LanguageServices {
  readonly views: LikeC4Views;
  readonly builder: LikeC4ModelBuilder;
  readonly workspaceUri: URI;
  readonly workspacePath: string;
  readonly projectsManager: ProjectsManager;
  readonly editor: LikeC4ModelChanges;
  /**
   * Returns all projects with relevant documents
   */
  projects(): NonEmptyArray$1<{
    id: ProjectId$1;
    folder: URI;
    title: string;
    documents: ReadonlyArray<URI>;
    config: Readonly<LikeC4ProjectConfig>;
  }>;
  /**
   * Returns project by ID, returns default project if no ID is specified
   */
  project(projectId?: ProjectId$1): {
    id: ProjectId$1;
    folder: URI;
    title: string;
    documents: ReadonlyArray<URI>;
    config: Readonly<LikeC4ProjectConfig>;
  };
  /**
   * Computes and layouts projects overview - a special diagram
   * that shows all projects and their relationships
   */
  projectsOverview(cancelToken?: CancellationToken$1): Promise<LayoutedProjectsView>;
  /**
   * Returns {@link LikeC4Model} of the specified project, with computed views {@link ComputedView}
   * Not ready for rendering, but enough to traverse model. Much faster than {@link layoutedModel}
   *
   * If no {@link project} is specified, returns for default project
   */
  computedModel(project?: ProjectId$1 | undefined, cancelToken?: CancellationToken$1): Promise<LikeC4Model<UnknownComputed>>;
  /**
   * Returns {@link LikeC4Model} of the specified project, with layouted views {@link LayoutedView}
   * Ready for rendering. Applies manual layouts if available.
   *
   * If no {@link project} is specified, returns for default project
   */
  layoutedModel(project?: ProjectId$1 | undefined, cancelToken?: CancellationToken$1): Promise<LikeC4Model<UnknownLayouted>>;
  /**
   * Returns diagrams (i.e. layouted views {@link LayoutedView}) for the specified project
   * Applies manual layouts if available.
   *
   * If no {@link project} is specified, returns diagrams for default project
   */
  diagrams(project?: ProjectId$1 | undefined, cancelToken?: CancellationToken$1): Promise<LayoutedView$1[]>;
  getErrors(): Array<{
    message: string;
    line: number;
    range: Range;
    sourceFsPath: string;
  }>;
  /**
   * Returns the location of the specified element, relation, view or deployment element
   */
  locate(params: Locate.Params): Locate.Res;
  /**
   * Formats documents and returns a map of document URI → formatted source text.
   *
   * Target selection uses union semantics:
   * - No options: formats all documents across all projects
   * - `projectIds`: includes all documents from those projects
   * - `documentUris`: includes specific documents
   * - Both: formats the union (deduplicated)
   */
  format(options?: FormatOptions): Promise<Map<string, string>>;
  dispose(): Promise<void>;
}
/**
 * Options for {@link LikeC4LanguageServices.format}.
 *
 * Target selection uses union semantics:
 * - Omit both `projectIds` and `documentUris` to format **all** documents.
 * - Provide `projectIds` to include all documents from those projects.
 * - Provide `documentUris` to include specific documents.
 * - Provide both to format the **union** of project documents and specified documents.
 */
interface FormatOptions {
  /** Include all documents from these projects. */
  projectIds?: ReadonlyArray<ProjectId$1>;
  /** Include these specific documents (by URI string). */
  documentUris?: ReadonlyArray<string>;
  /** Size of a tab in spaces (default: 2). */
  tabSize?: number;
  /** Prefer spaces over tabs (default: true). */
  insertSpaces?: boolean;
  /** Trim trailing whitespace on a line. */
  trimTrailingWhitespace?: boolean;
  /** Insert a newline character at the end of the file if one does not exist. */
  insertFinalNewline?: boolean;
  /** Trim all newlines after the final newline at the end of the file. */
  trimFinalNewlines?: boolean;
} //#endregion
//#region src/lsp/CodeLensProvider.d.ts
declare class LikeC4CodeLensProvider implements CodeLensProvider {
  private services;
  constructor(services: LikeC4Services);
  provideCodeLens(doc: LangiumDocument, _params: CodeLensParams, cancelToken?: CancellationToken$1): Promise<CodeLens[] | undefined>;
} //#endregion
//#region src/lsp/CompletionProvider.d.ts
declare class LikeC4CompletionProvider extends DefaultCompletionProvider {
  protected services: LikeC4Services;
  constructor(services: LikeC4Services);
  readonly completionOptions: {
    triggerCharacters: string[];
  };
  protected completionFor(context: CompletionContext, next: NextFeature, acceptor: CompletionAcceptor): MaybePromise<void>;
  protected completionForKeyword(context: CompletionContext, keyword: Keyword, acceptor: CompletionAcceptor): MaybePromise<void>;
  protected completionForImportedProject(context: CompletionContext, acceptor: CompletionAcceptor): void;
} //#endregion
//#region src/lsp/DocumentHighlightProvider.d.ts
declare class LikeC4DocumentHighlightProvider extends DefaultDocumentHighlightProvider {
  /**
   * Override this method to determine the highlight kind of the given reference.
   */
  protected createDocumentHighlight(reference: ReferenceDescription): DocumentHighlight;
} //#endregion
//#region src/lsp/DocumentLinkProvider.d.ts
declare class LikeC4DocumentLinkProvider implements DocumentLinkProvider {
  private services;
  constructor(services: LikeC4Services);
  getDocumentLinks(doc: LangiumDocument, _params: DocumentLinkParams, _cancelToken?: CancellationToken$1): Promise<DocumentLink[]>;
  resolveLink(doc: LangiumDocument, link: string): string;
  relativeLink(doc: LangiumDocument, link: string): string | null;
} //#endregion
//#region src/lsp/DocumentSymbolProvider.d.ts
declare class LikeC4DocumentSymbolProvider implements DocumentSymbolProvider {
  private services;
  protected readonly nodeKindProvider: NodeKindProvider;
  protected readonly nameProvider: LikeC4NameProvider;
  protected readonly parser: LikeC4ModelParser;
  protected readonly locator: LikeC4ModelLocator;
  constructor(services: LikeC4Services);
  getSymbols(doc: LangiumDocument, _params: DocumentSymbolParams, cancelToken?: CancellationToken$1): Promise<DocumentSymbol[]>;
  protected getLikec4LibSymbol(astLib: LikeC4Lib): DocumentSymbol[];
  protected getSpecSymbol(astSpec: SpecificationRule): DocumentSymbol[];
  protected getModelSymbol(astModel: Model): DocumentSymbol[];
  protected getDeploymentModelSymbol(astModel: ModelDeployments): DocumentSymbol[];
  protected getElementsSymbol(el: Element | Relation | ExtendElement, parentFqn?: string): DocumentSymbol[];
  protected getExtendElementSymbol(astElement: ExtendElement): DocumentSymbol[];
  protected getElementSymbol(astElement: Element): DocumentSymbol[];
  protected getModelViewsSymbol(astViews: ModelViews): DocumentSymbol[];
  protected getKindSymbol(astKind: SpecificationElementKind | SpecificationRelationshipKind): DocumentSymbol | null;
  protected getTagSymbol(astTag: SpecificationTag): DocumentSymbol | null;
  protected getLibIconSymbol(astTag: LibIcon): DocumentSymbol | null;
  protected getViewSymbol(astView: LikeC4View): DocumentSymbol[];
  protected getDeploymentElementSymbol(el: DeploymentElement | DeploymentRelation | ExtendDeployment): DocumentSymbol[];
  protected getDeploymentNodeSymbol(astElement: DeploymentNode): DocumentSymbol[];
  protected getDeployedInstanceSymbol(astElement: DeployedInstance): DocumentSymbol[];
  protected symbolKind(node: AstNode): SymbolKind;
} //#endregion
//#region src/lsp/HoverProvider.d.ts
/**
 * Provides hover content for LikeC4 AST nodes (elements, tags, relations, etc.)
 * in the language server. Resolves model references and formats markdown hover text.
 */
declare class LikeC4HoverProvider extends AstNodeHoverProvider {
  protected services: LikeC4Services;
  private parser;
  private locator;
  /** @param services - LikeC4 language services (parser, locator, etc.) */
  constructor(services: LikeC4Services);
  protected getAstNodeHoverContent(node: AstNode): MaybePromise<Hover | undefined>;
  /**
   * Builds hover content for an element node (title, summary, model details and view links).
   * @param node - The element AST node to generate hover content for.
   * @returns Hover information with markdown content, or undefined if element not found.
   */
  protected getElementHover(node: Element): MaybePromise<Hover | undefined>;
  /**
   * Builds markdown hover content for an element model (relationship counts and links to views).
   * @param model - The element model containing relationship and view information.
   * @param projectId - The project identifier for constructing view links.
   * @returns Markdown string with model details, or undefined if no details available.
   */
  protected getElementModelHover(model: ElementModel, projectId: ProjectId$1): string | undefined;
  /**
   * Builds hover content for a deployment node (id, title, kind, summary).
   * @param node - The deployment node AST node to generate hover content for.
   * @returns Hover information with markdown content.
   */
  protected getDeploymentNodeHover(node: DeploymentNode): MaybePromise<Hover | undefined>;
  /**
   * Builds hover content for a deployed instance (instance id, element ref, title and kind).
   * @param node - The deployed instance AST node to generate hover content for.
   * @returns Hover information with markdown content showing instance details.
   */
  protected getDeployedInstanceHover(node: DeployedInstance): MaybePromise<Hover | undefined>;
} //#endregion
//#region src/lsp/CodeActionProvider.d.ts
type CommandOrCodeAction = Command | CodeAction;
declare class LikeC4CodeActionProvider implements CodeActionProvider {
  /**
   * Handle a code action request.
   *
   * @throws `OperationCancelled` if cancellation is detected during execution
   * @throws `ResponseError` if an error is detected that should be sent as response to the client
   */
  getCodeActions(_document: LangiumDocument, _params: CodeActionParams): CommandOrCodeAction[] | undefined;
} //#endregion
//#region src/lsp/SemanticTokenProvider.d.ts
declare class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
  protected services: LikeC4Services;
  private rules;
  constructor(services: LikeC4Services);
  protected initRules(): void;
  protected highlightElement(node: AstNode, acceptor: SemanticTokenAcceptor): void | undefined | 'prune';
  private highlightNameAndKind;
  private highlightView;
  private mark;
} //#endregion
//#region src/Rpc.d.ts
declare class Rpc extends ADisposable {
  private services;
  constructor(services: LikeC4Services);
  init: () => void;
  openView(params: DidRequestOpenViewNotification.Params): Promise<void>;
} //#endregion
//#region src/shared/NodeKindProvider.d.ts
declare class NodeKindProvider$1 implements NodeKindProvider {
  private services;
  constructor(services: LangiumSharedServices);
  /**
   * Returns a `SymbolKind` as used by `WorkspaceSymbolProvider` or `DocumentSymbolProvider`.
   */
  getSymbolKind(node: AstNode | AstNodeDescription): SymbolKind;
  /**
   * Returns a `CompletionItemKind` as used by the `CompletionProvider`.
   */
  getCompletionItemKind(node: AstNode | AstNodeDescription): CompletionItemKind;
} //#endregion
//#region src/shared/WorkspaceSymbolProvider.d.ts
declare class WorkspaceSymbolProvider extends DefaultWorkspaceSymbolProvider {} //#endregion
//#region src/module.d.ts
interface LikeC4AddedSharedServices {
  lsp: {
    NodeKindProvider: NodeKindProvider$1;
    WorkspaceSymbolProvider: WorkspaceSymbolProvider;
  };
  workspace: {
    Cache: WorkspaceCache<string, any>;
    ProjectsManager: ProjectsManager;
    IndexManager: IndexManager;
    LangiumDocuments: LangiumDocuments;
    WorkspaceManager: LikeC4WorkspaceManager;
    FileSystemProvider: FileSystemProvider$1;
    FileSystemWatcher: FileSystemWatcher;
    ManualLayouts: LikeC4ManualLayouts;
  };
}
type LikeC4SharedServices = LangiumSharedServices & LikeC4AddedSharedServices;
/**
 * Declaration of custom services - add your own service classes here.
 */
interface LikeC4AddedServices {
  documentation: {
    DocumentationProvider: LikeC4DocumentationProvider;
  };
  validation: {
    DocumentValidator: LikeC4DocumentValidator;
  };
  Rpc: Rpc;
  likec4: {
    LanguageServices: LikeC4LanguageServices;
    Views: LikeC4Views;
    Graphviz: GraphvizPort;
    Layouter: QueueGraphvizLayoter;
    DeploymentsIndex: DeploymentsIndex;
    FqnIndex: FqnIndex;
    ModelParser: LikeC4ModelParser;
    ModelBuilder: LikeC4ModelBuilder;
    ModelLocator: LikeC4ModelLocator;
    ModelChanges: LikeC4ModelChanges;
    LastSeen: LastSeenArtifacts;
  };
  lsp: {
    CompletionProvider: LikeC4CompletionProvider;
    DocumentHighlightProvider: LikeC4DocumentHighlightProvider;
    DocumentSymbolProvider: LikeC4DocumentSymbolProvider;
    SemanticTokenProvider: LikeC4SemanticTokenProvider;
    HoverProvider: LikeC4HoverProvider;
    CodeLensProvider: LikeC4CodeLensProvider;
    DocumentLinkProvider: LikeC4DocumentLinkProvider;
    Formatter: LikeC4Formatter;
    CodeActionProvider: LikeC4CodeActionProvider;
  };
  references: {
    NameProvider: LikeC4NameProvider;
    ScopeComputation: LikeC4ScopeComputation;
    ScopeProvider: LikeC4ScopeProvider;
  };
  shared?: LikeC4SharedServices;
  parser: {
    ValueConverter: LikeC4ValueConverter;
  };
}
type LikeC4Services = LangiumServices & LikeC4AddedServices;
//#endregion
//#region ../language-services/dist/_chunks/options.d.mts
//#region src/common/LikeC4.d.ts
interface LikeC4Langium {
  shared: LikeC4SharedServices;
  likec4: LikeC4Services;
}
declare class LikeC4 {
  protected readonly langium: LikeC4Langium;
  protected readonly logger: Logger;
  constructor(langium: LikeC4Langium, logger?: Logger);
  /**
   * File system path to the workspace root
   */
  get workspace(): any;
  /**
   * URI of the workspace root
   */
  get workspaceURI(): any;
  /**
   * URL of the workspace root
   */
  get workspaceURL(): any;
  get languageServices(): LikeC4LanguageServices;
  get projectsManager(): ProjectsManager;
  get viewsService(): LikeC4Views;
  get modelBuilder(): LikeC4ModelBuilder;
  private get LangiumDocuments();
  ensureSingleProject(): void;
  /**
   * Diagram is a computed view, layouted using Graphviz
   * If diagram has manual layout, it will be used.
   * Used in React components
   */
  diagrams(project?: string | undefined): Promise<LayoutedView[]>;
  /**
   * Builds LikeC4Model from all documents
   * Only computes view predicates {@link ComputedView} - i.e. no layout
   * Not ready for rendering, but enough to traverse
   *
   * Sync version does not read manual layouts
   * Use {@link computedModel} for a version that includes manual layouts
   */
  syncComputedModel(project?: string | undefined): LikeC4Model.Computed;
  /**
   * Builds LikeC4Model from all documents
   * Only computes view predicates {@link ComputedView} - i.e. no layout
   * Not ready for rendering, but enough to traverse
   */
  computedModel(project?: string | undefined): Promise<LikeC4Model.Computed>;
  projects(): NonEmptyArray<ProjectId>;
  /**
   * Same as {@link computedModel()}, but also applies layout
   * Ready for rendering
   */
  layoutedModel(project?: string | undefined): Promise<LikeC4Model.Layouted>;
  getErrors(): Array<{
    message: string;
    line: number;
    range: {
      start: {
        line: number;
        character: number;
      };
      end: {
        line: number;
        character: number;
      };
    };
    sourceFsPath: string;
  }>;
  hasErrors(): boolean;
  /**
   * @returns true if there are errors
   */
  printErrors(): boolean;
  /**
   * Returns the number of parsed documents in the workspace
   */
  documentCount(): number;
  /**
   * @returns a function to dispose the listener
   */
  onModelUpdate(listener: () => void): () => void;
  /**
   * Formats documents and returns a map of document URI → formatted source text.
   *
   * Target selection uses union semantics:
   * - Omit both `projects` and `documentUris` to format **all** documents.
   * - Provide `projects` to include all documents from those projects.
   * - Provide `documentUris` to include specific documents.
   * - Provide both to format the **union** (deduplicated).
   */
  format(options?: LikeC4FormatOptions): Promise<Map<string, string>>;
  dispose(): Promise<void>;
  [Symbol.asyncDispose](): Promise<void>;
}
/**
 * Options for {@link LikeC4.format}.
 *
 * Same as {@link FormatOptions} but uses project name strings instead of {@link ProjectId}.
 */
interface LikeC4FormatOptions {
  /** Include all documents from these projects (by name). */
  projects?: ReadonlyArray<string>;
  /** Include these specific documents (by URI string). */
  documentUris?: ReadonlyArray<string>;
  /** Size of a tab in spaces (default: 2). */
  tabSize?: number;
  /** Prefer spaces over tabs (default: true). */
  insertSpaces?: boolean;
  /** Trim trailing whitespace on a line. */
  trimTrailingWhitespace?: boolean;
  /** Insert a newline character at the end of the file if one does not exist. */
  insertFinalNewline?: boolean;
  /** Trim all newlines after the final newline at the end of the file. */
  trimFinalNewlines?: boolean;
} //#endregion
//#region src/common/options.d.ts
//#endregion
export { LikeC4LanguageServices as n, LikeC4 as t };