@angular/language-service 22.0.0-next.5 → 22.0.0-next.6

package/src/references_and_rename.d.ts

@@ -0,0 +1,28 @@
+import { NgCompiler } from '@angular/compiler-cli/src/ngtsc/core';
+import ts from 'typescript';
+export declare class ReferencesBuilder {
+    private readonly tsLS;
+    private readonly compiler;
+    private readonly ttc;
+    constructor(tsLS: ts.LanguageService, compiler: NgCompiler);
+    getReferencesAtPosition(filePath: string, position: number): ts.ReferenceEntry[] | undefined;
+    private getReferencesAtTemplatePosition;
+    private getReferencesAtTypescriptPosition;
+}
+export declare class RenameBuilder {
+    private readonly tsLS;
+    private readonly compiler;
+    private readonly ttc;
+    constructor(tsLS: ts.LanguageService, compiler: NgCompiler);
+    getRenameInfo(filePath: string, position: number): Omit<ts.RenameInfoSuccess, 'kind' | 'kindModifiers'> | ts.RenameInfoFailure;
+    findRenameLocations(filePath: string, position: number): readonly ts.RenameLocation[] | null;
+    private findRenameLocationsAtTemplatePosition;
+    private findRenameLocationsAtTypescriptPosition;
+    private getTsNodeAtPosition;
+    private buildRenameRequestsFromTemplateDetails;
+    private buildRenameRequestAtTypescriptPosition;
+    private buildPipeRenameRequest;
+    private buildSelectorlessRenameRequest;
+    /** Gets the rename locations for a selectorless request. */
+    private getSelectorlessRenameLocations;
+}

package/src/references_and_rename_utils.d.ts

@@ -0,0 +1,72 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { AST, TmplAstNode, TmplAstComponent, TmplAstDirective, TmplAstRecursiveVisitor } from '@angular/compiler';
+import { NgCompiler } from '@angular/compiler-cli/src/ngtsc/core';
+import { DirectiveMeta, PipeMeta } from '@angular/compiler-cli/src/ngtsc/metadata';
+import { Symbol, TemplateTypeChecker } from '@angular/compiler-cli/src/ngtsc/typecheck/api';
+import ts from 'typescript';
+import { TypeCheckInfo } from './utils';
+/** Represents a location in a file. */
+export interface FilePosition {
+    fileName: string;
+    position: number;
+}
+export interface TemplateLocationDetails {
+    /**
+     * A target node in a template.
+     */
+    templateTarget: TmplAstNode | AST;
+    /**
+     * TypeScript locations which the template node maps to. A given template node might map to
+     * several TS nodes. For example, a template node for an attribute might resolve to several
+     * directives or a directive and one of its inputs.
+     */
+    typescriptLocations: FilePosition[];
+    /**
+     * The resolved Symbol for the template target.
+     */
+    symbol: Symbol;
+}
+/**
+ * Takes a position in a template and finds equivalent targets in TS files as well as details about
+ * the targeted template node.
+ */
+export declare function getTargetDetailsAtTemplatePosition(info: TypeCheckInfo, position: number, templateTypeChecker: TemplateTypeChecker): TemplateLocationDetails[] | null;
+/**
+ * Creates a "key" for a rename/reference location by concatenating file name, span start, and span
+ * length. This allows us to de-duplicate template results when an item may appear several times
+ * in the TCB but map back to the same template location.
+ */
+export declare function createLocationKey(ds: ts.DocumentSpan): string;
+/**
+ * Converts a given `ts.DocumentSpan` in a shim file to its equivalent `ts.DocumentSpan` in the
+ * template.
+ *
+ * You can optionally provide a `requiredNodeText` that ensures the equivalent template node's text
+ * matches. If it does not, this function will return `null`.
+ */
+export declare function convertToTemplateDocumentSpan<T extends ts.DocumentSpan>(shimDocumentSpan: T, templateTypeChecker: TemplateTypeChecker, program: ts.Program, requiredNodeText?: string): T | null;
+/**
+ * Finds the text and `ts.TextSpan` for the node at a position in a template.
+ */
+export declare function getRenameTextAndSpanAtPosition(node: TmplAstNode | AST, position: number): {
+    text: string;
+    span: ts.TextSpan;
+} | null;
+/**
+ * Retrieves the `PipeMeta` or `DirectiveMeta` of the given `ts.Node`'s parent class.
+ *
+ * Returns `null` if the node has no parent class or there is no meta associated with the class.
+ */
+export declare function getParentClassMeta(requestNode: ts.Node, compiler: NgCompiler): PipeMeta | DirectiveMeta | null;
+/** Visitor that collects all selectorless AST nodes from a template. */
+export declare class SelectorlessCollector extends TmplAstRecursiveVisitor {
+    private nodes;
+    static getSelectorlessNodes(nodes: TmplAstNode[]): (TmplAstComponent | TmplAstDirective)[];
+    visit(node: TmplAstNode): void;
+}

package/src/semantic_tokens.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { NgCompiler } from '@angular/compiler-cli/src/ngtsc/core';
+import ts from 'typescript';
+import { TypeCheckInfo } from './utils';
+/**
+ * see https://github.com/microsoft/TypeScript/blob/c85e626d8e17427a6865521737b45ccbbe9c78ef/src/services/classifier2020.ts#L49
+ */
+export declare const enum TokenEncodingConsts {
+    typeOffset = 8,
+    modifierMask = 255
+}
+/**
+ * Token types extended from TypeScript
+ * see https://github.com/microsoft/TypeScript/blob/c85e626d8e17427a6865521737b45ccbbe9c78ef/src/services/classifier2020.ts#L55
+ */
+export declare const enum TokenType {
+    class = 0,
+    enum = 1,
+    interface = 2,
+    namespace = 3,
+    typeParameter = 4,
+    type = 5,
+    parameter = 6,
+    variable = 7,
+    enumMember = 8,
+    property = 9,
+    function = 10,
+    member = 11
+}
+/**
+ * Token modifiers extended from TypeScript
+ * see https://github.com/microsoft/TypeScript/blob/c85e626d8e17427a6865521737b45ccbbe9c78ef/src/services/classifier2020.ts#L71
+ */
+export declare const enum TokenModifier {
+    declaration = 0,
+    static = 1,
+    async = 2,
+    readonly = 3,
+    defaultLibrary = 4,
+    local = 5
+}
+export declare function getClassificationsForTemplate(compiler: NgCompiler, typeCheckInfo: TypeCheckInfo, range: ts.TextSpan): ts.Classifications;

package/src/signature_help.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { NgCompiler } from '@angular/compiler-cli/src/ngtsc/core';
+import ts from 'typescript';
+/**
+ * Queries the TypeScript Language Service to get signature help for a template position.
+ */
+export declare function getSignatureHelp(compiler: NgCompiler, tsLS: ts.LanguageService, fileName: string, position: number, options: ts.SignatureHelpItemsOptions | undefined): ts.SignatureHelpItems | undefined;

package/src/template_target.d.ts

@@ -0,0 +1,178 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { AST, Call, SafeCall, TmplAstBoundAttribute, TmplAstBoundEvent, TmplAstComponent, TmplAstDirective, TmplAstElement, TmplAstNode, TmplAstTemplate, TmplAstTextAttribute } from '@angular/compiler';
+import tss from 'typescript';
+/**
+ * Contextual information for a target position within the template.
+ */
+export interface TemplateTarget {
+    /**
+     * Target position within the template.
+     */
+    position: number;
+    /**
+     * The template (or AST expression) node or nodes closest to the search position.
+     */
+    context: TargetContext;
+    /**
+     * The `TmplAstTemplate` which contains the found node or expression (or `null` if in the root
+     * template).
+     */
+    template: TmplAstTemplate | null;
+    /**
+     * The immediate parent node of the targeted node.
+     */
+    parent: TmplAstNode | AST | null;
+}
+/**
+ * A node or nodes targeted at a given position in the template, including potential contextual
+ * information about the specific aspect of the node being referenced.
+ *
+ * Some nodes have multiple interior contexts. For example, `TmplAstElement` nodes have both a tag
+ * name as well as a body, and a given position definitively points to one or the other.
+ * `TargetNode` captures the node itself, as well as this additional contextual disambiguation.
+ */
+export type TargetContext = SingleNodeTarget | MultiNodeTarget;
+/** Contexts which logically target only a single node in the template AST. */
+export type SingleNodeTarget = RawExpression | CallExpressionInArgContext | RawTemplateNode | ElementInBodyContext | ElementInTagContext | AttributeInKeyContext | AttributeInValueContext | ComponentInBodyContext | ComponentInTagContext | DirectiveInNameContext | DirectiveInBodyContext;
+/**
+ * Contexts which logically target multiple nodes in the template AST, which cannot be
+ * disambiguated given a single position because they are all equally relevant. For example, in the
+ * banana-in-a-box syntax `[(ngModel)]="formValues.person"`, the position in the template for the
+ * key `ngModel` refers to both the bound event `ngModelChange` and the input `ngModel`.
+ */
+export type MultiNodeTarget = TwoWayBindingContext;
+/**
+ * Differentiates the various kinds of `TargetNode`s.
+ */
+export declare enum TargetNodeKind {
+    RawExpression = 0,
+    CallExpressionInArgContext = 1,
+    RawTemplateNode = 2,
+    ElementInTagContext = 3,
+    ElementInBodyContext = 4,
+    AttributeInKeyContext = 5,
+    AttributeInValueContext = 6,
+    TwoWayBindingContext = 7,
+    ComponentInTagContext = 8,
+    ComponentInBodyContext = 9,
+    DirectiveInNameContext = 10,
+    DirectiveInBodyContext = 11
+}
+/**
+ * An `AST` expression that's targeted at a given position, with no additional context.
+ */
+export interface RawExpression {
+    kind: TargetNodeKind.RawExpression;
+    node: AST;
+    parents: AST[];
+}
+/**
+ * An `e.Call` expression with the cursor in a position where an argument could appear.
+ *
+ * This is returned when the only matching node is the method call expression, but the cursor is
+ * within the method call parentheses. For example, in the expression `foo(|)` there is no argument
+ * expression that the cursor could be targeting, but the cursor is in a position where one could
+ * appear.
+ */
+export interface CallExpressionInArgContext {
+    kind: TargetNodeKind.CallExpressionInArgContext;
+    node: Call | SafeCall;
+}
+/**
+ * A `TmplAstNode` template node that's targeted at a given position, with no additional context.
+ */
+export interface RawTemplateNode {
+    kind: TargetNodeKind.RawTemplateNode;
+    node: TmplAstNode;
+}
+/**
+ * A `TmplAstElement` (or `TmplAstTemplate`) element node that's targeted, where the given position
+ * is within the tag name.
+ */
+export interface ElementInTagContext {
+    kind: TargetNodeKind.ElementInTagContext;
+    node: TmplAstElement | TmplAstTemplate;
+}
+/**
+ * A `TmplAstElement` (or `TmplAstTemplate`) element node that's targeted, where the given position
+ * is within the element body.
+ */
+export interface ElementInBodyContext {
+    kind: TargetNodeKind.ElementInBodyContext;
+    node: TmplAstElement | TmplAstTemplate;
+}
+/**
+ * A `TmplAstComponent` element node that's targeted, where the given position is within the tag,
+ * e.g. `MyComp` in `<MyComp foo="bar"/>`.
+ */
+export interface ComponentInTagContext {
+    kind: TargetNodeKind.ComponentInTagContext;
+    node: TmplAstComponent;
+}
+/**
+ * A `TmplAstComponent` element node that's targeted, where the given position is within the body,
+ * e.g. `foo="bar"/>` in `<MyComp foo="bar"/>`.
+ */
+export interface ComponentInBodyContext {
+    kind: TargetNodeKind.ComponentInBodyContext;
+    node: TmplAstComponent;
+}
+/**
+ * A `TmplAstDirective` element node that's targeted, where the given position is within the
+ * directive's name (e.g. `MyDir` in `@MyDir`).
+ */
+export interface DirectiveInNameContext {
+    kind: TargetNodeKind.DirectiveInNameContext;
+    node: TmplAstDirective;
+}
+/**
+ * A `TmplAstDirective` element node that's targeted, where the given position is within the body,
+ * e.g. `(foo="bar")` in `@MyDir(foo="bar")`.
+ */
+export interface DirectiveInBodyContext {
+    kind: TargetNodeKind.DirectiveInBodyContext;
+    node: TmplAstDirective;
+}
+export interface AttributeInKeyContext {
+    kind: TargetNodeKind.AttributeInKeyContext;
+    node: TmplAstTextAttribute | TmplAstBoundAttribute | TmplAstBoundEvent;
+}
+export interface AttributeInValueContext {
+    kind: TargetNodeKind.AttributeInValueContext;
+    node: TmplAstTextAttribute | TmplAstBoundAttribute | TmplAstBoundEvent;
+}
+/**
+ * A `TmplAstBoundAttribute` and `TmplAstBoundEvent` pair that are targeted, where the given
+ * position is within the key span of both.
+ */
+export interface TwoWayBindingContext {
+    kind: TargetNodeKind.TwoWayBindingContext;
+    nodes: [TmplAstBoundAttribute, TmplAstBoundEvent];
+}
+/**
+ * Return the template AST node or expression AST node that most accurately
+ * represents the node at the specified cursor `position`.
+ *
+ * @param template AST tree of the template
+ * @param position target cursor position
+ */
+export declare function getTargetAtPosition(template: TmplAstNode[], position: number): TemplateTarget | null;
+/**
+ * A tcb nodes for the template at a given position, include the tcb node of the template.
+ */
+interface TcbNodesInfoForTemplate {
+    componentTcbNode: tss.Node;
+    nodes: tss.Node[];
+}
+/**
+ * Return the nodes in `TCB` of the node at the specified cursor `position`.
+ *
+ */
+export declare function getTcbNodesOfTemplateAtPosition(templateNodes: TmplAstNode[], position: number, tcb: tss.Node): TcbNodesInfoForTemplate | null;
+export {};

package/src/ts_plugin.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import type ts from 'typescript';
+import { NgLanguageService } from '../api';
+export declare function create(info: ts.server.PluginCreateInfo): NgLanguageService;
+/** Implementation of a ts.server.PluginModuleFactory */
+export declare function initialize(mod: {
+    typescript: typeof ts;
+}): ts.server.PluginModule;

package/src/utils/decorators.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import type ts from 'typescript';
+import { ReflectionHost } from '@angular/compiler-cli/src/ngtsc/reflection';
+export declare function isDirectiveOrComponent(node: ts.ClassDeclaration, reflector: ReflectionHost): boolean;

package/src/utils/display_parts.d.ts

@@ -0,0 +1,62 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { LetDeclarationSymbol, PotentialDirective, ReferenceSymbol, VariableSymbol } from '@angular/compiler-cli/src/ngtsc/typecheck/api';
+import ts from 'typescript';
+export declare const ALIAS_NAME: string;
+export declare const SYMBOL_INTERFACE: string;
+export declare const SYMBOL_PUNC: string;
+export declare const SYMBOL_SPACE: string;
+export declare const SYMBOL_TEXT: string;
+/**
+ * Label for various kinds of Angular entities for TS display info.
+ */
+export declare enum DisplayInfoKind {
+    ATTRIBUTE = "attribute",
+    BLOCK = "block",
+    TRIGGER = "trigger",
+    COMPONENT = "component",
+    DIRECTIVE = "directive",
+    EVENT = "event",
+    REFERENCE = "reference",
+    ELEMENT = "element",
+    VARIABLE = "variable",
+    PIPE = "pipe",
+    PROPERTY = "property",
+    METHOD = "method",
+    TEMPLATE = "template",
+    KEYWORD = "keyword",
+    LET = "let"
+}
+export interface DisplayInfo {
+    kind: DisplayInfoKind;
+    displayParts: ts.SymbolDisplayPart[];
+    documentation: ts.SymbolDisplayPart[] | undefined;
+    tags: ts.JSDocTagInfo[] | undefined;
+}
+export declare function getSymbolDisplayInfo(tsLS: ts.LanguageService, typeChecker: ts.TypeChecker, symbol: ReferenceSymbol | VariableSymbol | LetDeclarationSymbol): DisplayInfo;
+/**
+ * Construct a compound `ts.SymbolDisplayPart[]` which incorporates the container and type of a
+ * target declaration.
+ * @param name Name of the target
+ * @param kind component, directive, pipe, etc.
+ * @param containerName either the Symbol's container or the NgModule that contains the directive
+ * @param type user-friendly name of the type
+ * @param documentation docstring or comment
+ */
+export declare function createDisplayParts(name: string, kind: DisplayInfoKind, containerName: string | undefined, type: string | undefined): ts.SymbolDisplayPart[];
+/**
+ * Convert a `SymbolDisplayInfoKind` to a `ts.ScriptElementKind` type, allowing it to pass through
+ * TypeScript APIs.
+ *
+ * In practice, this is an "illegal" type cast. Since `ts.ScriptElementKind` is a string, this is
+ * safe to do if TypeScript only uses the value in a string context. Consumers of this conversion
+ * function are responsible for ensuring this is the case.
+ */
+export declare function unsafeCastDisplayInfoKindToScriptElementKind(kind: DisplayInfoKind): ts.ScriptElementKind;
+export declare function getDirectiveDisplayInfo(tsLS: ts.LanguageService, dir: PotentialDirective): DisplayInfo;
+export declare function getTsSymbolDisplayInfo(tsLS: ts.LanguageService, checker: ts.TypeChecker, symbol: ts.Symbol, kind: DisplayInfoKind, ownerName: string | null): DisplayInfo | null;

package/src/utils/format.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import ts from 'typescript';
+/**
+ * Try to guess the indentation of the node.
+ *
+ * This function returns the indentation only if the start character of this node is
+ * the first non-whitespace character in a line where the node is, otherwise,
+ * it returns `undefined`. When computing the start of the node, it should include
+ * the leading comments.
+ */
+export declare function guessIndentationInSingleLine(node: ts.Node, sourceFile: ts.SourceFile): number | undefined;

package/src/utils/index.d.ts

@@ -0,0 +1,89 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { AbsoluteSourceSpan, AST, ParseSourceSpan, ParseSpan, PropertyRead, TmplAstBoundEvent, TmplAstElement, TmplAstNode, TmplAstTemplate } from '@angular/compiler';
+import { NgCompiler } from '@angular/compiler-cli/src/ngtsc/core';
+import { AbsoluteFsPath } from '@angular/compiler-cli/src/ngtsc/file_system';
+import { DirectiveSymbol, TemplateTypeChecker } from '@angular/compiler-cli/src/ngtsc/typecheck/api';
+import ts from 'typescript';
+import { DisplayInfoKind } from './display_parts';
+export declare function getTextSpanOfNode(node: TmplAstNode | AST): ts.TextSpan;
+export declare function toTextSpan(span: AbsoluteSourceSpan | ParseSourceSpan | ParseSpan): ts.TextSpan;
+interface NodeWithKeyAndValue extends TmplAstNode {
+    keySpan: ParseSourceSpan;
+    valueSpan?: ParseSourceSpan;
+}
+export declare function isTemplateNodeWithKeyAndValue(node: TmplAstNode | AST): node is NodeWithKeyAndValue;
+export declare function isWithinKey(position: number, node: NodeWithKeyAndValue): boolean;
+export declare function isWithinKeyValue(position: number, node: NodeWithKeyAndValue): boolean;
+export declare function isTemplateNode(node: TmplAstNode | AST): node is TmplAstNode;
+export declare function isExpressionNode(node: TmplAstNode | AST): node is AST;
+export interface TypeCheckInfo {
+    nodes: TmplAstNode[];
+    declaration: ts.ClassDeclaration;
+}
+/**
+ * Retrieves the `ts.ClassDeclaration` at a location along with its template AST nodes.
+ */
+export declare function getTypeCheckInfoAtPosition(fileName: string, position: number, compiler: NgCompiler): TypeCheckInfo | undefined;
+export declare function getFirstComponentForTemplateFile(fileName: string, compiler: NgCompiler): TypeCheckInfo | undefined;
+/**
+ * Given an element or template, determines which directives match because the tag is present. For
+ * example, if a directive selector is `div[myAttr]`, this would match div elements but would not if
+ * the selector were just `[myAttr]`. We find which directives are applied because of this tag by
+ * elimination: compare the directive matches with the tag present against the directive matches
+ * without it. The difference would be the directives which match because the tag is present.
+ *
+ * @param element The element or template node that the attribute/tag is part of.
+ * @param directives The list of directives to match against.
+ * @returns The list of directives matching the tag name via the strategy described above.
+ */
+export declare function getDirectiveMatchesForElementTag<T extends {
+    selector: string | null;
+}>(element: TmplAstTemplate | TmplAstElement, directives: T[]): Set<T>;
+export declare function makeElementSelector(element: TmplAstElement | TmplAstTemplate): string;
+/**
+ * Given an attribute name, determines which directives match because the attribute is present. We
+ * find which directives are applied because of this attribute by elimination: compare the directive
+ * matches with the attribute present against the directive matches without it. The difference would
+ * be the directives which match because the attribute is present.
+ *
+ * @param name The name of the attribute
+ * @param hostNode The node which the attribute appears on
+ * @param directives The list of directives to match against.
+ * @returns The list of directives matching the tag name via the strategy described above.
+ */
+export declare function getDirectiveMatchesForAttribute(name: string, hostNode: TmplAstTemplate | TmplAstElement, directives: DirectiveSymbol[]): Set<DirectiveSymbol>;
+/**
+ * Returns a new `ts.SymbolDisplayPart` array which has the alias imports from the tcb filtered
+ * out, i.e. `i0.NgForOf`.
+ */
+export declare function filterAliasImports(displayParts: ts.SymbolDisplayPart[]): ts.SymbolDisplayPart[];
+export declare function isDollarEvent(n: TmplAstNode | AST): n is PropertyRead;
+export declare function isTypeScriptFile(fileName: string): boolean;
+export declare function isExternalTemplate(fileName: string): boolean;
+export declare function isWithin(position: number, span: AbsoluteSourceSpan | ParseSourceSpan): boolean;
+/**
+ * For a given location in a shim file, retrieves the corresponding file url for the template and
+ * the span in the template.
+ */
+export declare function getTemplateLocationFromTcbLocation(templateTypeChecker: TemplateTypeChecker, tcbPath: AbsoluteFsPath, tcbIsShim: boolean, positionInFile: number): {
+    templateUrl: AbsoluteFsPath;
+    span: ParseSourceSpan;
+} | null;
+export declare function isBoundEventWithSyntheticHandler(event: TmplAstBoundEvent): boolean;
+/**
+ * Construct a QuickInfo object taking into account its container and type.
+ * @param name Name of the QuickInfo target
+ * @param kind component, directive, pipe, etc.
+ * @param textSpan span of the target
+ * @param containerName either the Symbol's container or the NgModule that contains the directive
+ * @param type user-friendly name of the type
+ * @param documentation docstring or comment
+ */
+export declare function createQuickInfo(name: string, kind: DisplayInfoKind, textSpan: ts.TextSpan, containerName?: string, type?: string, documentation?: ts.SymbolDisplayPart[], tags?: ts.JSDocTagInfo[]): ts.QuickInfo;
+export {};