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

package/src/completions.d.ts

@@ -0,0 +1,113 @@
+/**
+ * @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/src/ngtsc/core';
+import ts from 'typescript';
+import { TemplateTarget } from './template_target';
+export declare enum CompletionNodeContext {
+    None = 0,
+    ElementTag = 1,
+    ElementAttributeKey = 2,
+    ElementAttributeValue = 3,
+    EventValue = 4,
+    TwoWayBinding = 5
+}
+/**
+ * Performs autocompletion operations on a given node in the template.
+ *
+ * This class acts as a closure around all of the context required to perform the 3 autocompletion
+ * operations (completions, get details, and get symbol) at a specific node.
+ *
+ * The generic `N` type for the template node is narrowed internally for certain operations, as the
+ * compiler operations required to implement completion may be different for different node types.
+ *
+ * @param N type of the template node in question, narrowed accordingly.
+ */
+export declare class CompletionBuilder<N extends TmplAstNode | AST> {
+    private readonly tsLS;
+    private readonly compiler;
+    private readonly component;
+    private readonly node;
+    private readonly targetDetails;
+    private readonly typeChecker;
+    private readonly templateTypeChecker;
+    private readonly nodeParent;
+    private readonly nodeContext;
+    private readonly template;
+    private readonly position;
+    constructor(tsLS: ts.LanguageService, compiler: NgCompiler, component: ts.ClassDeclaration, node: N, targetDetails: TemplateTarget);
+    /**
+     * Analogue for `ts.LanguageService.getCompletionsAtPosition`.
+     */
+    getCompletionsAtPosition(options: ts.GetCompletionsAtPositionOptions | undefined): ts.WithMetadata<ts.CompletionInfo> | undefined;
+    private isLetCompletion;
+    private isBlockCompletion;
+    private getBlockCompletions;
+    private isLiteralCompletion;
+    private getLiteralCompletions;
+    /**
+     * Analogue for `ts.LanguageService.getCompletionEntryDetails`.
+     */
+    getCompletionEntryDetails(entryName: string, formatOptions: ts.FormatCodeOptions | ts.FormatCodeSettings | undefined, preferences: ts.UserPreferences | undefined, data: ts.CompletionEntryData | undefined): ts.CompletionEntryDetails | undefined;
+    /**
+     * Analogue for `ts.LanguageService.getCompletionEntrySymbol`.
+     */
+    getCompletionEntrySymbol(name: string): ts.Symbol | undefined;
+    /**
+     * Determine if the current node is the completion of a property expression, and narrow the type
+     * of `this.node` if so.
+     *
+     * This narrowing gives access to additional methods related to completion of property
+     * expressions.
+     */
+    private isPropertyExpressionCompletion;
+    /**
+     * Get completions for property expressions.
+     */
+    private getPropertyExpressionCompletion;
+    /**
+     * Get the details of a specific completion for a property expression.
+     */
+    private getPropertyExpressionCompletionDetails;
+    /**
+     * Get the `ts.Symbol` for a specific completion for a property expression.
+     */
+    private getPropertyExpressionCompletionSymbol;
+    /**
+     * Get completions for a property expression in a global context (e.g. `{{y|}}`).
+     */
+    private getGlobalPropertyExpressionCompletion;
+    /**
+     * Get the details of a specific completion for a property expression in a global context (e.g.
+     * `{{y|}}`).
+     */
+    private getGlobalPropertyExpressionCompletionDetails;
+    /**
+     * Get the `ts.Symbol` of a specific completion for a property expression in a global context
+     * (e.g. `{{y|}}`).
+     */
+    private getGlobalPropertyExpressionCompletionSymbol;
+    private isElementTagCompletion;
+    private getElementTagCompletion;
+    private getTsNodeAtPosition;
+    private getElementTagCompletionDetails;
+    private getElementTagCompletionSymbol;
+    private isAnimationCompletion;
+    private getAnimationCompletions;
+    private isElementAttributeCompletion;
+    private getElementAttributeCompletions;
+    private getElementAttributeCompletionDetails;
+    private getElementAttributeCompletionSymbol;
+    private isPipeCompletion;
+    private getPipeCompletions;
+    /**
+     * From the AST node of the cursor position, include completion of string literals, number
+     * literals, `true`, `false`, `null`, and `undefined`.
+     */
+    private isValidNodeContextCompletion;
+}

package/src/definitions.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @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';
+export declare class DefinitionBuilder {
+    private readonly tsLS;
+    private readonly compiler;
+    private readonly ttc;
+    constructor(tsLS: ts.LanguageService, compiler: NgCompiler);
+    getDefinitionAndBoundSpan(fileName: string, position: number): ts.DefinitionInfoAndBoundSpan | undefined;
+    private getDefinitionsForSymbol;
+    private getDefinitionsForSymbols;
+    /**
+     * Converts and definition info result that points to a template typecheck file to a reference to
+     * the corresponding location in the template.
+     */
+    private mapShimResultsToTemplates;
+    getTypeDefinitionsAtPosition(fileName: string, position: number): readonly ts.DefinitionInfo[] | undefined;
+    private getTypeDefinitionsForTemplateInstance;
+    private getDirectiveTypeDefsForBindingNode;
+    private getTypeDefinitionsForSymbols;
+    private getDefinitionMetaAtPosition;
+}

package/src/document_symbols.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @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 { AngularSymbolKind, DocumentSymbolsOptions, TemplateDocumentSymbol } from '../api';
+export type { AngularSymbolKind, DocumentSymbolsOptions, TemplateDocumentSymbol };
+/**
+ * Gets document symbols for Angular templates in the given file.
+ * For TypeScript files with inline templates, returns symbols for each template.
+ * For external template files (.html), returns symbols for the template content.
+ *
+ * @param compiler The Angular compiler instance
+ * @param fileName The file path to get template symbols for
+ * @param options Optional configuration for document symbols behavior
+ */
+export declare function getTemplateDocumentSymbols(compiler: NgCompiler, fileName: string, options?: DocumentSymbolsOptions): TemplateDocumentSymbol[];

package/src/inlay_hints.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @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';
+export type { AngularInlayHint, InlayHintsConfig, InlayHintDisplayPart } from '../api';
+import type { AngularInlayHint, InlayHintsConfig } from '../api';
+/**
+ * Get Angular-specific inlay hints for a template.
+ */
+export declare function getInlayHintsForTemplate(compiler: NgCompiler, typeCheckInfo: TypeCheckInfo, span: ts.TextSpan, config?: InlayHintsConfig): AngularInlayHint[];

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 ts from 'typescript';
+import { ApplyRefactoringProgressFn, ApplyRefactoringResult, AngularInlayHint, GetComponentLocationsForTemplateResponse, InlayHintsConfig, GetTcbResponse, GetTemplateLocationForComponentResponse, LinkedEditingRanges, PluginConfig } from '../api';
+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/src/ngtsc/core';
+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/src/ngtsc/core';
+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/src/ngtsc/core';
+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,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 { CompilerOptions } from '@angular/compiler-cli';
+import { NgCompiler } from '@angular/compiler-cli/src/ngtsc/core';
+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/src/ngtsc/reflection';
+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,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 } from '@angular/compiler-cli';
+import { NgCompiler } from '@angular/compiler-cli/src/ngtsc/core';
+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,39 @@
+/**
+ * @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 { NgCompiler } from '@angular/compiler-cli/src/ngtsc/core';
+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,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 { CompilerOptions } from '@angular/compiler-cli';
+import { NgCompiler } from '@angular/compiler-cli/src/ngtsc/core';
+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/src/ngtsc/reflection';
+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,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 } from '@angular/compiler-cli';
+import { NgCompiler } from '@angular/compiler-cli/src/ngtsc/core';
+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,39 @@
+/**
+ * @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 { NgCompiler } from '@angular/compiler-cli/src/ngtsc/core';
+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,45 @@
+/**
+ * @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 type ts from 'typescript';
+import { ApplyRefactoringProgressFn, ApplyRefactoringResult } from '../../api';
+import { CompilerOptions } from '@angular/compiler-cli';
+/**
+ * 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[];