@angular/language-service 21.2.5 → 21.2.7

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[];

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;