@angular/language-service 22.0.0-next.1 → 22.0.0-next.10

package/src/language_service.d.ts

@@ -0,0 +1,132 @@
+/**
+ * @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 { CompilerOptions } from '@angular/compiler-cli';
+import { AngularInlayHint, ApplyRefactoringProgressFn, ApplyRefactoringResult, GetComponentLocationsForTemplateResponse, GetTcbResponse, GetTemplateLocationForComponentResponse, InlayHintsConfig, LinkedEditingRanges, PluginConfig } from '../api';
+import ts from 'typescript';
+import { CompilerFactory } from './compiler_factory';
+import { DocumentSymbolsOptions, TemplateDocumentSymbol } from './document_symbols';
+export declare class LanguageService {
+    private readonly project;
+    private readonly tsLS;
+    private readonly config;
+    private options;
+    readonly compilerFactory: CompilerFactory;
+    private readonly codeFixes;
+    private readonly activeRefactorings;
+    constructor(project: ts.server.Project, tsLS: ts.LanguageService, config: Omit<PluginConfig, 'angularOnly'>);
+    getCompilerOptions(): CompilerOptions;
+    /**
+     * Triggers the Angular compiler's analysis pipeline without performing
+     * per-file type checking.
+     */
+    ensureProjectAnalyzed(): void;
+    getSemanticDiagnostics(fileName: string): ts.Diagnostic[];
+    getSuggestionDiagnostics(fileName: string): ts.DiagnosticWithLocation[];
+    getDefinitionAndBoundSpan(fileName: string, position: number): ts.DefinitionInfoAndBoundSpan | undefined;
+    getTypeDefinitionAtPosition(fileName: string, position: number): readonly ts.DefinitionInfo[] | undefined;
+    getQuickInfoAtPosition(fileName: string, position: number): ts.QuickInfo | undefined;
+    /**
+     * Provide Angular-specific inlay hints for templates.
+     *
+     * This returns hints for:
+     * - @for loop variable types: `@for (user: User of users)`
+     * - @if alias types: `@if (data; as result: ApiResult)`
+     * - Event parameter types: `(click)="onClick($event: MouseEvent)"`
+     * - Pipe output types: `{{ value | async: Observable<T> }}`
+     * - @let declaration types
+     *
+     * @param fileName The file to get inlay hints for
+     * @param span The text span to get hints within
+     * @param config Optional configuration for which hints to show
+     */
+    provideInlayHints(fileName: string, span: ts.TextSpan, config?: InlayHintsConfig): AngularInlayHint[];
+    private getQuickInfoAtPositionImpl;
+    getReferencesAtPosition(fileName: string, position: number): ts.ReferenceEntry[] | undefined;
+    getRenameInfo(fileName: string, position: number): ts.RenameInfo;
+    findRenameLocations(fileName: string, position: number): readonly ts.RenameLocation[] | undefined;
+    /**
+     * Gets linked editing ranges for synchronized editing of HTML tag pairs.
+     *
+     * When the cursor is on an element tag name, returns both the opening and closing
+     * tag name spans so they can be edited simultaneously.
+     *
+     * @param fileName The file to check
+     * @param position The cursor position in the file
+     * @returns LinkedEditingRanges if on a tag name, undefined otherwise
+     */
+    getLinkedEditingRangeAtPosition(fileName: string, position: number): LinkedEditingRanges | undefined;
+    private getCompletionBuilder;
+    getEncodedSemanticClassifications(fileName: string, span: ts.TextSpan, format: ts.SemanticClassificationFormat | undefined): ts.Classifications;
+    private getEncodedSemanticClassificationsImpl;
+    getTokenTypeFromClassification(classification: number): number | undefined;
+    getTokenModifierFromClassification(classification: number): number;
+    getCompletionsAtPosition(fileName: string, position: number, options: ts.GetCompletionsAtPositionOptions | undefined): ts.WithMetadata<ts.CompletionInfo> | undefined;
+    private getCompletionsAtPositionImpl;
+    getCompletionEntryDetails(fileName: string, position: number, entryName: string, formatOptions: ts.FormatCodeOptions | ts.FormatCodeSettings | undefined, preferences: ts.UserPreferences | undefined, data: ts.CompletionEntryData | undefined): ts.CompletionEntryDetails | undefined;
+    getSignatureHelpItems(fileName: string, position: number, options?: ts.SignatureHelpItemsOptions): ts.SignatureHelpItems | undefined;
+    getOutliningSpans(fileName: string): ts.OutliningSpan[];
+    /**
+     * Gets document symbols for Angular templates, including control flow blocks,
+     * elements, components, template references, and @let declarations.
+     * Returns symbols in NavigationTree format for compatibility with TypeScript.
+     *
+     * @param fileName The file path to get template symbols for
+     * @param options Optional configuration for document symbols behavior
+     */
+    getTemplateDocumentSymbols(fileName: string, options?: DocumentSymbolsOptions): TemplateDocumentSymbol[];
+    getCompletionEntrySymbol(fileName: string, position: number, entryName: string): ts.Symbol | undefined;
+    /**
+     * Performance helper that can help make quick decisions for
+     * the VSCode language server to decide whether a code fix exists
+     * for the given error code.
+     *
+     * Related context: https://github.com/angular/vscode-ng-language-service/pull/2050#discussion_r1673079263
+     */
+    hasCodeFixesForErrorCode(errorCode: number): boolean;
+    getCodeFixesAtPosition(fileName: string, start: number, end: number, errorCodes: readonly number[], formatOptions: ts.FormatCodeSettings, preferences: ts.UserPreferences): readonly ts.CodeFixAction[];
+    getCombinedCodeFix(scope: ts.CombinedCodeFixScope, fixId: string, formatOptions: ts.FormatCodeSettings, preferences: ts.UserPreferences): ts.CombinedCodeActions;
+    getComponentLocationsForTemplate(fileName: string): GetComponentLocationsForTemplateResponse;
+    getTemplateLocationForComponent(fileName: string, position: number): GetTemplateLocationForComponentResponse;
+    getTcb(fileName: string, position: number): GetTcbResponse | undefined;
+    getPossibleRefactorings(fileName: string, positionOrRange: number | ts.TextRange): ts.ApplicableRefactorInfo[];
+    /**
+     * Computes edits for applying the specified refactoring.
+     *
+     * VSCode explicitly split code actions into two stages:
+     *
+     *  - 1) what actions are active?
+     *  - 2) what are the edits? <- if the user presses the button
+     *
+     * The latter stage may take longer to compute complex edits, perform
+     * analysis. This stage is currently implemented via our non-LSP standard
+     * `applyRefactoring` method. We implemented it in a way to support asynchronous
+     * computation, so that it can easily integrate with migrations that aren't
+     * synchronous/or compute edits in parallel.
+     */
+    applyRefactoring(fileName: string, positionOrRange: number | ts.TextRange, refactorName: string, reportProgress: ApplyRefactoringProgressFn): Promise<ApplyRefactoringResult | undefined>;
+    /**
+     * Provides an instance of the `NgCompiler` and traces perf results. Perf results are logged only
+     * if the log level is verbose or higher. This method is intended to be called once per public
+     * method call.
+     *
+     * Here is an example of the log output.
+     *
+     * Perf 245  [16:16:39.353] LanguageService#getQuickInfoAtPosition(): {"events":{},"phases":{
+     * "Unaccounted":379,"TtcSymbol":4},"memory":{}}
+     *
+     * Passing name of caller instead of using `arguments.caller` because 'caller', 'callee', and
+     * 'arguments' properties may not be accessed in strict mode.
+     *
+     * @param phase the `PerfPhase` to execute the `p` callback in
+     * @param p callback to be run synchronously with an instance of the `NgCompiler` as argument
+     * @return the result of running the `p` callback
+     */
+    private withCompilerAndPerfTracing;
+    getCompilerOptionsDiagnostics(): ts.Diagnostic[];
+    private watchConfigFile;
+}

package/src/linked_editing_range.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @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';
+import { LinkedEditingRanges } from '../api';
+/**
+ * Gets linked editing ranges for synchronized editing of HTML tag pairs.
+ *
+ * When the cursor is on an element tag name, returns both the opening and closing
+ * tag name spans so they can be edited simultaneously.
+ *
+ * @param compiler The Angular compiler instance
+ * @param fileName The file to check
+ * @param position The cursor position in the file
+ * @returns LinkedEditingRanges if on a tag name, null otherwise
+ */
+export declare function getLinkedEditingRangeAtPosition(compiler: NgCompiler, fileName: string, position: number): LinkedEditingRanges | null;

package/src/outlining_spans.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 { NgCompiler } from '@angular/compiler-cli';
+import ts from 'typescript';
+export declare function getOutliningSpans(compiler: NgCompiler, fileName: string): ts.OutliningSpan[];

package/src/quick_info.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @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 } from '@angular/compiler';
+import { NgCompiler } from '@angular/compiler-cli';
+import ts from 'typescript';
+import { TemplateTarget } from './template_target';
+export declare class QuickInfoBuilder {
+    private readonly tsLS;
+    private readonly compiler;
+    private readonly component;
+    private node;
+    private readonly positionDetails;
+    private readonly typeChecker;
+    private readonly parent;
+    constructor(tsLS: ts.LanguageService, compiler: NgCompiler, component: ts.ClassDeclaration, node: TmplAstNode | AST, positionDetails: TemplateTarget);
+    get(): ts.QuickInfo | undefined;
+    private getQuickInfoForSymbol;
+    private getQuickInfoForBindingSymbol;
+    private getQuickInfoForElementSymbol;
+    private getQuickInfoForVariableSymbol;
+    private getQuickInfoForLetDeclarationSymbol;
+    private getQuickInfoForReferenceSymbol;
+    private getQuickInfoForPipeSymbol;
+    private getQuickInfoForDomBinding;
+    private getQuickInfoForDirectiveSymbol;
+    private getQuickInfoForSelectorlessSymbol;
+    private getQuickInfoFromTypeDefAtLocation;
+    private getQuickInfoAtTcbLocation;
+}

package/src/quick_info_built_ins.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 { AST, Call, TmplAstBlockNode, TmplAstDeferredTrigger, TmplAstNode } from '@angular/compiler';
+import type ts from 'typescript';
+export declare function isDollarAny(node: TmplAstNode | AST): node is Call;
+export declare function createDollarAnyQuickInfo(node: Call): ts.QuickInfo;
+export declare function createNgTemplateQuickInfo(node: TmplAstNode | AST): ts.QuickInfo;
+export declare function createQuickInfoForBuiltIn(node: TmplAstDeferredTrigger | TmplAstBlockNode, cursorPositionInTemplate: number): ts.QuickInfo | undefined;

package/src/refactorings/convert_to_signal_input/apply_input_refactoring.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @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 { CompilerOptions, NgCompiler } from '@angular/compiler-cli';
+import type ts from 'typescript';
+import { KnownInputInfo, MigrationConfig } from '@angular/core/schematics/migrations/signal-migration/src';
+import { ApplyRefactoringProgressFn, ApplyRefactoringResult } from '../../../api';
+export declare function applySignalInputRefactoring(compiler: NgCompiler, compilerOptions: CompilerOptions, config: MigrationConfig, project: ts.server.Project, reportProgress: ApplyRefactoringProgressFn, shouldMigrateInput: (input: KnownInputInfo) => boolean, multiMode: boolean): Promise<ApplyRefactoringResult>;

package/src/refactorings/convert_to_signal_input/decorators.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @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';
+export declare function isDecoratorInputClassField(node: ts.ClassElement, reflector: ReflectionHost): boolean;
+export declare function isDirectiveOrComponentWithInputs(node: ts.ClassDeclaration, reflector: ReflectionHost): boolean;

package/src/refactorings/convert_to_signal_input/full_class_input_refactoring.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @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 { CompilerOptions, NgCompiler } from '@angular/compiler-cli';
+import { MigrationConfig } from '@angular/core/schematics/migrations/signal-migration/src';
+import { ApplyRefactoringProgressFn, ApplyRefactoringResult } from '../../../api';
+import ts from 'typescript';
+import type { ActiveRefactoring } from '../refactoring';
+/**
+ * Base language service refactoring action that can convert `@Input()`
+ * declarations of a full class to signal inputs.
+ *
+ * The user can click on an class with `@Input`s and ask for all the input to be migrated.
+ * All references, imports and the declaration are updated automatically.
+ */
+declare abstract class BaseConvertFullClassToSignalInputsRefactoring implements ActiveRefactoring {
+    private project;
+    abstract config: MigrationConfig;
+    constructor(project: ts.server.Project);
+    static isApplicable(compiler: NgCompiler, fileName: string, positionOrRange: number | ts.TextRange): boolean;
+    computeEditsForFix(compiler: NgCompiler, compilerOptions: CompilerOptions, fileName: string, positionOrRange: number | ts.TextRange, reportProgress: ApplyRefactoringProgressFn): Promise<ApplyRefactoringResult>;
+}
+export declare class ConvertFullClassToSignalInputsRefactoring extends BaseConvertFullClassToSignalInputsRefactoring {
+    static id: string;
+    static description: string;
+    config: MigrationConfig;
+}
+export declare class ConvertFullClassToSignalInputsBestEffortRefactoring extends BaseConvertFullClassToSignalInputsRefactoring {
+    static id: string;
+    static description: string;
+    config: MigrationConfig;
+}
+export {};

package/src/refactorings/convert_to_signal_input/individual_input_refactoring.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @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 { CompilerOptions, NgCompiler } from '@angular/compiler-cli';
+import { MigrationConfig } from '@angular/core/schematics/migrations/signal-migration/src';
+import { ApplyRefactoringProgressFn, ApplyRefactoringResult } from '../../../api';
+import ts from 'typescript';
+import type { ActiveRefactoring } from '../refactoring';
+/**
+ * Base language service refactoring action that can convert a
+ * single individual `@Input()` declaration to a signal inputs
+ *
+ * The user can click on an `@Input` property declaration in e.g. the VSCode
+ * extension and ask for the input to be migrated. All references, imports and
+ * the declaration are updated automatically.
+ */
+declare abstract class BaseConvertFieldToSignalInputRefactoring implements ActiveRefactoring {
+    private project;
+    abstract config: MigrationConfig;
+    constructor(project: ts.server.Project);
+    static isApplicable(compiler: NgCompiler, fileName: string, positionOrRange: number | ts.TextRange): boolean;
+    computeEditsForFix(compiler: NgCompiler, compilerOptions: CompilerOptions, fileName: string, positionOrRange: number | ts.TextRange, reportProgress: ApplyRefactoringProgressFn): Promise<ApplyRefactoringResult>;
+}
+export declare class ConvertFieldToSignalInputRefactoring extends BaseConvertFieldToSignalInputRefactoring {
+    static id: string;
+    static description: string;
+    config: MigrationConfig;
+}
+export declare class ConvertFieldToSignalInputBestEffortRefactoring extends BaseConvertFieldToSignalInputRefactoring {
+    static id: string;
+    static description: string;
+    config: MigrationConfig;
+}
+export {};

package/src/refactorings/convert_to_signal_queries/apply_query_refactoring.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @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 { CompilerOptions, NgCompiler } from '@angular/compiler-cli';
+import ts from 'typescript';
+import { ApplyRefactoringProgressFn, ApplyRefactoringResult } from '../../../api';
+import { MigrationConfig } from '@angular/core/schematics/migrations/signal-queries-migration';
+export declare function applySignalQueriesRefactoring(compiler: NgCompiler, compilerOptions: CompilerOptions, config: MigrationConfig, project: ts.server.Project, reportProgress: ApplyRefactoringProgressFn, shouldMigrateQuery: NonNullable<MigrationConfig['shouldMigrateQuery']>, multiMode: boolean): Promise<ApplyRefactoringResult>;

package/src/refactorings/convert_to_signal_queries/decorators.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @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';
+export declare function isDecoratorQueryClassField(node: ts.ClassElement, reflector: ReflectionHost): boolean;
+export declare function isDirectiveOrComponentWithQueries(node: ts.ClassDeclaration, reflector: ReflectionHost): boolean;

package/src/refactorings/convert_to_signal_queries/full_class_query_refactoring.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @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 { CompilerOptions, NgCompiler } from '@angular/compiler-cli';
+import { MigrationConfig } from '@angular/core/schematics/migrations/signal-migration/src';
+import { ApplyRefactoringProgressFn, ApplyRefactoringResult } from '../../../api';
+import ts from 'typescript';
+import type { ActiveRefactoring } from '../refactoring';
+/**
+ * Base language service refactoring action that can convert decorator
+ * queries of a full class to signal queries.
+ *
+ * The user can click on an class with decorator queries and ask for all the queries
+ * to be migrated. All references, imports and the declaration are updated automatically.
+ */
+declare abstract class BaseConvertFullClassToSignalQueriesRefactoring implements ActiveRefactoring {
+    private project;
+    abstract config: MigrationConfig;
+    constructor(project: ts.server.Project);
+    static isApplicable(compiler: NgCompiler, fileName: string, positionOrRange: number | ts.TextRange): boolean;
+    computeEditsForFix(compiler: NgCompiler, compilerOptions: CompilerOptions, fileName: string, positionOrRange: number | ts.TextRange, reportProgress: ApplyRefactoringProgressFn): Promise<ApplyRefactoringResult>;
+}
+export declare class ConvertFullClassToSignalQueriesRefactoring extends BaseConvertFullClassToSignalQueriesRefactoring {
+    static id: string;
+    static description: string;
+    config: MigrationConfig;
+}
+export declare class ConvertFullClassToSignalQueriesBestEffortRefactoring extends BaseConvertFullClassToSignalQueriesRefactoring {
+    static id: string;
+    static description: string;
+    config: MigrationConfig;
+}
+export {};

package/src/refactorings/convert_to_signal_queries/individual_query_refactoring.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @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 { CompilerOptions, NgCompiler } from '@angular/compiler-cli';
+import { ApplyRefactoringProgressFn, ApplyRefactoringResult } from '../../../api';
+import ts from 'typescript';
+import type { ActiveRefactoring } from '../refactoring';
+import { MigrationConfig } from '../../../../core/schematics/migrations/signal-queries-migration';
+/**
+ * Base language service refactoring action that can convert a
+ * single individual decorator query declaration to a signal query
+ *
+ * The user can click on an `@ViewChild` property declaration in e.g. the VSCode
+ * extension and ask for the query to be migrated. All references, imports and
+ * the declaration are updated automatically.
+ */
+declare abstract class BaseConvertFieldToSignalQueryRefactoring implements ActiveRefactoring {
+    private project;
+    abstract config: MigrationConfig;
+    constructor(project: ts.server.Project);
+    static isApplicable(compiler: NgCompiler, fileName: string, positionOrRange: number | ts.TextRange): boolean;
+    computeEditsForFix(compiler: NgCompiler, compilerOptions: CompilerOptions, fileName: string, positionOrRange: number | ts.TextRange, reportProgress: ApplyRefactoringProgressFn): Promise<ApplyRefactoringResult>;
+}
+export declare class ConvertFieldToSignalQueryRefactoring extends BaseConvertFieldToSignalQueryRefactoring {
+    static id: string;
+    static description: string;
+    config: MigrationConfig;
+}
+export declare class ConvertFieldToSignalQueryBestEffortRefactoring extends BaseConvertFieldToSignalQueryRefactoring {
+    static id: string;
+    static description: string;
+    config: MigrationConfig;
+}
+export {};

package/src/refactorings/refactoring.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @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 { ApplyRefactoringProgressFn, ApplyRefactoringResult } from '../../api';
+import { CompilerOptions, NgCompiler } from '@angular/compiler-cli';
+import type ts from 'typescript';
+/**
+ * Interface exposing static metadata for a {@link Refactoring},
+ * exposed via static fields.
+ *
+ * A refactoring may be applicable at a given position inside
+ * a file. If it becomes applicable, the language service will suggest
+ * it as a code action.
+ *
+ * Later, the user can request edits for the refactoring lazily, upon
+ * e.g. click. The refactoring class is then instantiated and will be
+ * re-used for future applications, allowing for efficient re-use of e.g
+ * analysis data.
+ */
+export interface Refactoring {
+    new (project: ts.server.Project): ActiveRefactoring;
+    /** Unique id of the refactoring. */
+    id: string;
+    /** Description of the refactoring. Shown in e.g. VSCode as the code action. */
+    description: string;
+    /** Whether the refactoring is applicable at the given location. */
+    isApplicable(compiler: NgCompiler, fileName: string, positionOrRange: number | ts.TextRange): boolean;
+}
+/**
+ * Interface that describes an active refactoring instance. A
+ * refactoring may be lazily instantiated whenever the refactoring
+ * is requested to be applied.
+ *
+ * More information can be found in {@link Refactoring}
+ */
+export interface ActiveRefactoring {
+    /** Computes the edits for the refactoring. */
+    computeEditsForFix(compiler: NgCompiler, compilerOptions: CompilerOptions, fileName: string, positionOrRange: number | ts.TextRange, reportProgress: ApplyRefactoringProgressFn): Promise<ApplyRefactoringResult>;
+}
+export declare const allRefactorings: Refactoring[];

package/src/references_and_rename.d.ts

@@ -0,0 +1,28 @@
+import { NgCompiler } from '@angular/compiler-cli';
+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,70 @@
+/**
+ * @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, TmplAstComponent, TmplAstDirective, TmplAstNode, TmplAstRecursiveVisitor } from '@angular/compiler';
+import { DirectiveMeta, NgCompiler, PipeMeta, Symbol, TemplateTypeChecker } from '@angular/compiler-cli';
+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';
+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';
+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;