/**
|
* Declaration module describing the TypeScript Server protocol
|
*/
|
declare namespace ts.server.protocol {
|
const enum CommandTypes {
|
JsxClosingTag = "jsxClosingTag",
|
Brace = "brace",
|
BraceCompletion = "braceCompletion",
|
GetSpanOfEnclosingComment = "getSpanOfEnclosingComment",
|
Change = "change",
|
Close = "close",
|
/** @deprecated Prefer CompletionInfo -- see comment on CompletionsResponse */
|
Completions = "completions",
|
CompletionInfo = "completionInfo",
|
CompletionDetails = "completionEntryDetails",
|
CompileOnSaveAffectedFileList = "compileOnSaveAffectedFileList",
|
CompileOnSaveEmitFile = "compileOnSaveEmitFile",
|
Configure = "configure",
|
Definition = "definition",
|
DefinitionAndBoundSpan = "definitionAndBoundSpan",
|
Implementation = "implementation",
|
Exit = "exit",
|
FileReferences = "fileReferences",
|
Format = "format",
|
Formatonkey = "formatonkey",
|
Geterr = "geterr",
|
GeterrForProject = "geterrForProject",
|
SemanticDiagnosticsSync = "semanticDiagnosticsSync",
|
SyntacticDiagnosticsSync = "syntacticDiagnosticsSync",
|
SuggestionDiagnosticsSync = "suggestionDiagnosticsSync",
|
NavBar = "navbar",
|
Navto = "navto",
|
NavTree = "navtree",
|
NavTreeFull = "navtree-full",
|
/** @deprecated */
|
Occurrences = "occurrences",
|
DocumentHighlights = "documentHighlights",
|
Open = "open",
|
Quickinfo = "quickinfo",
|
References = "references",
|
Reload = "reload",
|
Rename = "rename",
|
Saveto = "saveto",
|
SignatureHelp = "signatureHelp",
|
Status = "status",
|
TypeDefinition = "typeDefinition",
|
ProjectInfo = "projectInfo",
|
ReloadProjects = "reloadProjects",
|
Unknown = "unknown",
|
OpenExternalProject = "openExternalProject",
|
OpenExternalProjects = "openExternalProjects",
|
CloseExternalProject = "closeExternalProject",
|
UpdateOpen = "updateOpen",
|
GetOutliningSpans = "getOutliningSpans",
|
TodoComments = "todoComments",
|
Indentation = "indentation",
|
DocCommentTemplate = "docCommentTemplate",
|
CompilerOptionsForInferredProjects = "compilerOptionsForInferredProjects",
|
GetCodeFixes = "getCodeFixes",
|
GetCombinedCodeFix = "getCombinedCodeFix",
|
ApplyCodeActionCommand = "applyCodeActionCommand",
|
GetSupportedCodeFixes = "getSupportedCodeFixes",
|
GetApplicableRefactors = "getApplicableRefactors",
|
GetEditsForRefactor = "getEditsForRefactor",
|
OrganizeImports = "organizeImports",
|
GetEditsForFileRename = "getEditsForFileRename",
|
ConfigurePlugin = "configurePlugin",
|
SelectionRange = "selectionRange",
|
ToggleLineComment = "toggleLineComment",
|
ToggleMultilineComment = "toggleMultilineComment",
|
CommentSelection = "commentSelection",
|
UncommentSelection = "uncommentSelection",
|
PrepareCallHierarchy = "prepareCallHierarchy",
|
ProvideCallHierarchyIncomingCalls = "provideCallHierarchyIncomingCalls",
|
ProvideCallHierarchyOutgoingCalls = "provideCallHierarchyOutgoingCalls",
|
ProvideInlayHints = "provideInlayHints"
|
}
|
/**
|
* A TypeScript Server message
|
*/
|
interface Message {
|
/**
|
* Sequence number of the message
|
*/
|
seq: number;
|
/**
|
* One of "request", "response", or "event"
|
*/
|
type: "request" | "response" | "event";
|
}
|
/**
|
* Client-initiated request message
|
*/
|
interface Request extends Message {
|
type: "request";
|
/**
|
* The command to execute
|
*/
|
command: string;
|
/**
|
* Object containing arguments for the command
|
*/
|
arguments?: any;
|
}
|
/**
|
* Request to reload the project structure for all the opened files
|
*/
|
interface ReloadProjectsRequest extends Message {
|
command: CommandTypes.ReloadProjects;
|
}
|
/**
|
* Server-initiated event message
|
*/
|
interface Event extends Message {
|
type: "event";
|
/**
|
* Name of event
|
*/
|
event: string;
|
/**
|
* Event-specific information
|
*/
|
body?: any;
|
}
|
/**
|
* Response by server to client request message.
|
*/
|
interface Response extends Message {
|
type: "response";
|
/**
|
* Sequence number of the request message.
|
*/
|
request_seq: number;
|
/**
|
* Outcome of the request.
|
*/
|
success: boolean;
|
/**
|
* The command requested.
|
*/
|
command: string;
|
/**
|
* If success === false, this should always be provided.
|
* Otherwise, may (or may not) contain a success message.
|
*/
|
message?: string;
|
/**
|
* Contains message body if success === true.
|
*/
|
body?: any;
|
/**
|
* Contains extra information that plugin can include to be passed on
|
*/
|
metadata?: unknown;
|
/**
|
* Exposes information about the performance of this request-response pair.
|
*/
|
performanceData?: PerformanceData;
|
}
|
interface PerformanceData {
|
/**
|
* Time spent updating the program graph, in milliseconds.
|
*/
|
updateGraphDurationMs?: number;
|
/**
|
* The time spent creating or updating the auto-import program, in milliseconds.
|
*/
|
createAutoImportProviderProgramDurationMs?: number;
|
}
|
/**
|
* Arguments for FileRequest messages.
|
*/
|
interface FileRequestArgs {
|
/**
|
* The file for the request (absolute pathname required).
|
*/
|
file: string;
|
projectFileName?: string;
|
}
|
interface StatusRequest extends Request {
|
command: CommandTypes.Status;
|
}
|
interface StatusResponseBody {
|
/**
|
* The TypeScript version (`ts.version`).
|
*/
|
version: string;
|
}
|
/**
|
* Response to StatusRequest
|
*/
|
interface StatusResponse extends Response {
|
body: StatusResponseBody;
|
}
|
/**
|
* Requests a JS Doc comment template for a given position
|
*/
|
interface DocCommentTemplateRequest extends FileLocationRequest {
|
command: CommandTypes.DocCommentTemplate;
|
}
|
/**
|
* Response to DocCommentTemplateRequest
|
*/
|
interface DocCommandTemplateResponse extends Response {
|
body?: TextInsertion;
|
}
|
/**
|
* A request to get TODO comments from the file
|
*/
|
interface TodoCommentRequest extends FileRequest {
|
command: CommandTypes.TodoComments;
|
arguments: TodoCommentRequestArgs;
|
}
|
/**
|
* Arguments for TodoCommentRequest request.
|
*/
|
interface TodoCommentRequestArgs extends FileRequestArgs {
|
/**
|
* Array of target TodoCommentDescriptors that describes TODO comments to be found
|
*/
|
descriptors: TodoCommentDescriptor[];
|
}
|
/**
|
* Response for TodoCommentRequest request.
|
*/
|
interface TodoCommentsResponse extends Response {
|
body?: TodoComment[];
|
}
|
/**
|
* A request to determine if the caret is inside a comment.
|
*/
|
interface SpanOfEnclosingCommentRequest extends FileLocationRequest {
|
command: CommandTypes.GetSpanOfEnclosingComment;
|
arguments: SpanOfEnclosingCommentRequestArgs;
|
}
|
interface SpanOfEnclosingCommentRequestArgs extends FileLocationRequestArgs {
|
/**
|
* Requires that the enclosing span be a multi-line comment, or else the request returns undefined.
|
*/
|
onlyMultiLine: boolean;
|
}
|
/**
|
* Request to obtain outlining spans in file.
|
*/
|
interface OutliningSpansRequest extends FileRequest {
|
command: CommandTypes.GetOutliningSpans;
|
}
|
interface OutliningSpan {
|
/** The span of the document to actually collapse. */
|
textSpan: TextSpan;
|
/** The span of the document to display when the user hovers over the collapsed span. */
|
hintSpan: TextSpan;
|
/** The text to display in the editor for the collapsed region. */
|
bannerText: string;
|
/**
|
* Whether or not this region should be automatically collapsed when
|
* the 'Collapse to Definitions' command is invoked.
|
*/
|
autoCollapse: boolean;
|
/**
|
* Classification of the contents of the span
|
*/
|
kind: OutliningSpanKind;
|
}
|
/**
|
* Response to OutliningSpansRequest request.
|
*/
|
interface OutliningSpansResponse extends Response {
|
body?: OutliningSpan[];
|
}
|
/**
|
* A request to get indentation for a location in file
|
*/
|
interface IndentationRequest extends FileLocationRequest {
|
command: CommandTypes.Indentation;
|
arguments: IndentationRequestArgs;
|
}
|
/**
|
* Response for IndentationRequest request.
|
*/
|
interface IndentationResponse extends Response {
|
body?: IndentationResult;
|
}
|
/**
|
* Indentation result representing where indentation should be placed
|
*/
|
interface IndentationResult {
|
/**
|
* The base position in the document that the indent should be relative to
|
*/
|
position: number;
|
/**
|
* The number of columns the indent should be at relative to the position's column.
|
*/
|
indentation: number;
|
}
|
/**
|
* Arguments for IndentationRequest request.
|
*/
|
interface IndentationRequestArgs extends FileLocationRequestArgs {
|
/**
|
* An optional set of settings to be used when computing indentation.
|
* If argument is omitted - then it will use settings for file that were previously set via 'configure' request or global settings.
|
*/
|
options?: EditorSettings;
|
}
|
/**
|
* Arguments for ProjectInfoRequest request.
|
*/
|
interface ProjectInfoRequestArgs extends FileRequestArgs {
|
/**
|
* Indicate if the file name list of the project is needed
|
*/
|
needFileNameList: boolean;
|
}
|
/**
|
* A request to get the project information of the current file.
|
*/
|
interface ProjectInfoRequest extends Request {
|
command: CommandTypes.ProjectInfo;
|
arguments: ProjectInfoRequestArgs;
|
}
|
/**
|
* A request to retrieve compiler options diagnostics for a project
|
*/
|
interface CompilerOptionsDiagnosticsRequest extends Request {
|
arguments: CompilerOptionsDiagnosticsRequestArgs;
|
}
|
/**
|
* Arguments for CompilerOptionsDiagnosticsRequest request.
|
*/
|
interface CompilerOptionsDiagnosticsRequestArgs {
|
/**
|
* Name of the project to retrieve compiler options diagnostics.
|
*/
|
projectFileName: string;
|
}
|
/**
|
* Response message body for "projectInfo" request
|
*/
|
interface ProjectInfo {
|
/**
|
* For configured project, this is the normalized path of the 'tsconfig.json' file
|
* For inferred project, this is undefined
|
*/
|
configFileName: string;
|
/**
|
* The list of normalized file name in the project, including 'lib.d.ts'
|
*/
|
fileNames?: string[];
|
/**
|
* Indicates if the project has a active language service instance
|
*/
|
languageServiceDisabled?: boolean;
|
}
|
/**
|
* Represents diagnostic info that includes location of diagnostic in two forms
|
* - start position and length of the error span
|
* - startLocation and endLocation - a pair of Location objects that store start/end line and offset of the error span.
|
*/
|
interface DiagnosticWithLinePosition {
|
message: string;
|
start: number;
|
length: number;
|
startLocation: Location;
|
endLocation: Location;
|
category: string;
|
code: number;
|
/** May store more in future. For now, this will simply be `true` to indicate when a diagnostic is an unused-identifier diagnostic. */
|
reportsUnnecessary?: {};
|
reportsDeprecated?: {};
|
relatedInformation?: DiagnosticRelatedInformation[];
|
}
|
/**
|
* Response message for "projectInfo" request
|
*/
|
interface ProjectInfoResponse extends Response {
|
body?: ProjectInfo;
|
}
|
/**
|
* Request whose sole parameter is a file name.
|
*/
|
interface FileRequest extends Request {
|
arguments: FileRequestArgs;
|
}
|
/**
|
* Instances of this interface specify a location in a source file:
|
* (file, line, character offset), where line and character offset are 1-based.
|
*/
|
interface FileLocationRequestArgs extends FileRequestArgs {
|
/**
|
* The line number for the request (1-based).
|
*/
|
line: number;
|
/**
|
* The character offset (on the line) for the request (1-based).
|
*/
|
offset: number;
|
}
|
type FileLocationOrRangeRequestArgs = FileLocationRequestArgs | FileRangeRequestArgs;
|
/**
|
* Request refactorings at a given position or selection area.
|
*/
|
interface GetApplicableRefactorsRequest extends Request {
|
command: CommandTypes.GetApplicableRefactors;
|
arguments: GetApplicableRefactorsRequestArgs;
|
}
|
type GetApplicableRefactorsRequestArgs = FileLocationOrRangeRequestArgs & {
|
triggerReason?: RefactorTriggerReason;
|
kind?: string;
|
};
|
type RefactorTriggerReason = "implicit" | "invoked";
|
/**
|
* Response is a list of available refactorings.
|
* Each refactoring exposes one or more "Actions"; a user selects one action to invoke a refactoring
|
*/
|
interface GetApplicableRefactorsResponse extends Response {
|
body?: ApplicableRefactorInfo[];
|
}
|
/**
|
* A set of one or more available refactoring actions, grouped under a parent refactoring.
|
*/
|
interface ApplicableRefactorInfo {
|
/**
|
* The programmatic name of the refactoring
|
*/
|
name: string;
|
/**
|
* A description of this refactoring category to show to the user.
|
* If the refactoring gets inlined (see below), this text will not be visible.
|
*/
|
description: string;
|
/**
|
* Inlineable refactorings can have their actions hoisted out to the top level
|
* of a context menu. Non-inlineanable refactorings should always be shown inside
|
* their parent grouping.
|
*
|
* If not specified, this value is assumed to be 'true'
|
*/
|
inlineable?: boolean;
|
actions: RefactorActionInfo[];
|
}
|
/**
|
* Represents a single refactoring action - for example, the "Extract Method..." refactor might
|
* offer several actions, each corresponding to a surround class or closure to extract into.
|
*/
|
interface RefactorActionInfo {
|
/**
|
* The programmatic name of the refactoring action
|
*/
|
name: string;
|
/**
|
* A description of this refactoring action to show to the user.
|
* If the parent refactoring is inlined away, this will be the only text shown,
|
* so this description should make sense by itself if the parent is inlineable=true
|
*/
|
description: string;
|
/**
|
* A message to show to the user if the refactoring cannot be applied in
|
* the current context.
|
*/
|
notApplicableReason?: string;
|
/**
|
* The hierarchical dotted name of the refactor action.
|
*/
|
kind?: string;
|
}
|
interface GetEditsForRefactorRequest extends Request {
|
command: CommandTypes.GetEditsForRefactor;
|
arguments: GetEditsForRefactorRequestArgs;
|
}
|
/**
|
* Request the edits that a particular refactoring action produces.
|
* Callers must specify the name of the refactor and the name of the action.
|
*/
|
type GetEditsForRefactorRequestArgs = FileLocationOrRangeRequestArgs & {
|
refactor: string;
|
action: string;
|
};
|
interface GetEditsForRefactorResponse extends Response {
|
body?: RefactorEditInfo;
|
}
|
interface RefactorEditInfo {
|
edits: FileCodeEdits[];
|
/**
|
* An optional location where the editor should start a rename operation once
|
* the refactoring edits have been applied
|
*/
|
renameLocation?: Location;
|
renameFilename?: string;
|
}
|
/**
|
* Organize imports by:
|
* 1) Removing unused imports
|
* 2) Coalescing imports from the same module
|
* 3) Sorting imports
|
*/
|
interface OrganizeImportsRequest extends Request {
|
command: CommandTypes.OrganizeImports;
|
arguments: OrganizeImportsRequestArgs;
|
}
|
type OrganizeImportsScope = GetCombinedCodeFixScope;
|
interface OrganizeImportsRequestArgs {
|
scope: OrganizeImportsScope;
|
skipDestructiveCodeActions?: boolean;
|
}
|
interface OrganizeImportsResponse extends Response {
|
body: readonly FileCodeEdits[];
|
}
|
interface GetEditsForFileRenameRequest extends Request {
|
command: CommandTypes.GetEditsForFileRename;
|
arguments: GetEditsForFileRenameRequestArgs;
|
}
|
/** Note: Paths may also be directories. */
|
interface GetEditsForFileRenameRequestArgs {
|
readonly oldFilePath: string;
|
readonly newFilePath: string;
|
}
|
interface GetEditsForFileRenameResponse extends Response {
|
body: readonly FileCodeEdits[];
|
}
|
/**
|
* Request for the available codefixes at a specific position.
|
*/
|
interface CodeFixRequest extends Request {
|
command: CommandTypes.GetCodeFixes;
|
arguments: CodeFixRequestArgs;
|
}
|
interface GetCombinedCodeFixRequest extends Request {
|
command: CommandTypes.GetCombinedCodeFix;
|
arguments: GetCombinedCodeFixRequestArgs;
|
}
|
interface GetCombinedCodeFixResponse extends Response {
|
body: CombinedCodeActions;
|
}
|
interface ApplyCodeActionCommandRequest extends Request {
|
command: CommandTypes.ApplyCodeActionCommand;
|
arguments: ApplyCodeActionCommandRequestArgs;
|
}
|
interface ApplyCodeActionCommandResponse extends Response {
|
}
|
interface FileRangeRequestArgs extends FileRequestArgs {
|
/**
|
* The line number for the request (1-based).
|
*/
|
startLine: number;
|
/**
|
* The character offset (on the line) for the request (1-based).
|
*/
|
startOffset: number;
|
/**
|
* The line number for the request (1-based).
|
*/
|
endLine: number;
|
/**
|
* The character offset (on the line) for the request (1-based).
|
*/
|
endOffset: number;
|
}
|
/**
|
* Instances of this interface specify errorcodes on a specific location in a sourcefile.
|
*/
|
interface CodeFixRequestArgs extends FileRangeRequestArgs {
|
/**
|
* Errorcodes we want to get the fixes for.
|
*/
|
errorCodes: readonly number[];
|
}
|
interface GetCombinedCodeFixRequestArgs {
|
scope: GetCombinedCodeFixScope;
|
fixId: {};
|
}
|
interface GetCombinedCodeFixScope {
|
type: "file";
|
args: FileRequestArgs;
|
}
|
interface ApplyCodeActionCommandRequestArgs {
|
/** May also be an array of commands. */
|
command: {};
|
}
|
/**
|
* Response for GetCodeFixes request.
|
*/
|
interface GetCodeFixesResponse extends Response {
|
body?: CodeAction[];
|
}
|
/**
|
* A request whose arguments specify a file location (file, line, col).
|
*/
|
interface FileLocationRequest extends FileRequest {
|
arguments: FileLocationRequestArgs;
|
}
|
/**
|
* A request to get codes of supported code fixes.
|
*/
|
interface GetSupportedCodeFixesRequest extends Request {
|
command: CommandTypes.GetSupportedCodeFixes;
|
}
|
/**
|
* A response for GetSupportedCodeFixesRequest request.
|
*/
|
interface GetSupportedCodeFixesResponse extends Response {
|
/**
|
* List of error codes supported by the server.
|
*/
|
body?: string[];
|
}
|
/**
|
* A request to get encoded semantic classifications for a span in the file
|
*/
|
interface EncodedSemanticClassificationsRequest extends FileRequest {
|
arguments: EncodedSemanticClassificationsRequestArgs;
|
}
|
/**
|
* Arguments for EncodedSemanticClassificationsRequest request.
|
*/
|
interface EncodedSemanticClassificationsRequestArgs extends FileRequestArgs {
|
/**
|
* Start position of the span.
|
*/
|
start: number;
|
/**
|
* Length of the span.
|
*/
|
length: number;
|
/**
|
* Optional parameter for the semantic highlighting response, if absent it
|
* defaults to "original".
|
*/
|
format?: "original" | "2020";
|
}
|
/** The response for a EncodedSemanticClassificationsRequest */
|
interface EncodedSemanticClassificationsResponse extends Response {
|
body?: EncodedSemanticClassificationsResponseBody;
|
}
|
/**
|
* Implementation response message. Gives series of text spans depending on the format ar.
|
*/
|
interface EncodedSemanticClassificationsResponseBody {
|
endOfLineState: EndOfLineState;
|
spans: number[];
|
}
|
/**
|
* Arguments in document highlight request; include: filesToSearch, file,
|
* line, offset.
|
*/
|
interface DocumentHighlightsRequestArgs extends FileLocationRequestArgs {
|
/**
|
* List of files to search for document highlights.
|
*/
|
filesToSearch: string[];
|
}
|
/**
|
* Go to definition request; value of command field is
|
* "definition". Return response giving the file locations that
|
* define the symbol found in file at location line, col.
|
*/
|
interface DefinitionRequest extends FileLocationRequest {
|
command: CommandTypes.Definition;
|
}
|
interface DefinitionAndBoundSpanRequest extends FileLocationRequest {
|
readonly command: CommandTypes.DefinitionAndBoundSpan;
|
}
|
interface DefinitionAndBoundSpanResponse extends Response {
|
readonly body: DefinitionInfoAndBoundSpan;
|
}
|
/**
|
* Go to type request; value of command field is
|
* "typeDefinition". Return response giving the file locations that
|
* define the type for the symbol found in file at location line, col.
|
*/
|
interface TypeDefinitionRequest extends FileLocationRequest {
|
command: CommandTypes.TypeDefinition;
|
}
|
/**
|
* Go to implementation request; value of command field is
|
* "implementation". Return response giving the file locations that
|
* implement the symbol found in file at location line, col.
|
*/
|
interface ImplementationRequest extends FileLocationRequest {
|
command: CommandTypes.Implementation;
|
}
|
/**
|
* Location in source code expressed as (one-based) line and (one-based) column offset.
|
*/
|
interface Location {
|
line: number;
|
offset: number;
|
}
|
/**
|
* Object found in response messages defining a span of text in source code.
|
*/
|
interface TextSpan {
|
/**
|
* First character of the definition.
|
*/
|
start: Location;
|
/**
|
* One character past last character of the definition.
|
*/
|
end: Location;
|
}
|
/**
|
* Object found in response messages defining a span of text in a specific source file.
|
*/
|
interface FileSpan extends TextSpan {
|
/**
|
* File containing text span.
|
*/
|
file: string;
|
}
|
interface JSDocTagInfo {
|
/** Name of the JSDoc tag */
|
name: string;
|
/**
|
* Comment text after the JSDoc tag -- the text after the tag name until the next tag or end of comment
|
* Display parts when UserPreferences.displayPartsForJSDoc is true, flattened to string otherwise.
|
*/
|
text?: string | SymbolDisplayPart[];
|
}
|
interface TextSpanWithContext extends TextSpan {
|
contextStart?: Location;
|
contextEnd?: Location;
|
}
|
interface FileSpanWithContext extends FileSpan, TextSpanWithContext {
|
}
|
interface DefinitionInfo extends FileSpanWithContext {
|
/**
|
* When true, the file may or may not exist.
|
*/
|
unverified?: boolean;
|
}
|
interface DefinitionInfoAndBoundSpan {
|
definitions: readonly DefinitionInfo[];
|
textSpan: TextSpan;
|
}
|
/**
|
* Definition response message. Gives text range for definition.
|
*/
|
interface DefinitionResponse extends Response {
|
body?: DefinitionInfo[];
|
}
|
interface DefinitionInfoAndBoundSpanResponse extends Response {
|
body?: DefinitionInfoAndBoundSpan;
|
}
|
/** @deprecated Use `DefinitionInfoAndBoundSpanResponse` instead. */
|
type DefinitionInfoAndBoundSpanReponse = DefinitionInfoAndBoundSpanResponse;
|
/**
|
* Definition response message. Gives text range for definition.
|
*/
|
interface TypeDefinitionResponse extends Response {
|
body?: FileSpanWithContext[];
|
}
|
/**
|
* Implementation response message. Gives text range for implementations.
|
*/
|
interface ImplementationResponse extends Response {
|
body?: FileSpanWithContext[];
|
}
|
/**
|
* Request to get brace completion for a location in the file.
|
*/
|
interface BraceCompletionRequest extends FileLocationRequest {
|
command: CommandTypes.BraceCompletion;
|
arguments: BraceCompletionRequestArgs;
|
}
|
/**
|
* Argument for BraceCompletionRequest request.
|
*/
|
interface BraceCompletionRequestArgs extends FileLocationRequestArgs {
|
/**
|
* Kind of opening brace
|
*/
|
openingBrace: string;
|
}
|
interface JsxClosingTagRequest extends FileLocationRequest {
|
readonly command: CommandTypes.JsxClosingTag;
|
readonly arguments: JsxClosingTagRequestArgs;
|
}
|
interface JsxClosingTagRequestArgs extends FileLocationRequestArgs {
|
}
|
interface JsxClosingTagResponse extends Response {
|
readonly body: TextInsertion;
|
}
|
/**
|
* @deprecated
|
* Get occurrences request; value of command field is
|
* "occurrences". Return response giving spans that are relevant
|
* in the file at a given line and column.
|
*/
|
interface OccurrencesRequest extends FileLocationRequest {
|
command: CommandTypes.Occurrences;
|
}
|
/** @deprecated */
|
interface OccurrencesResponseItem extends FileSpanWithContext {
|
/**
|
* True if the occurrence is a write location, false otherwise.
|
*/
|
isWriteAccess: boolean;
|
/**
|
* True if the occurrence is in a string, undefined otherwise;
|
*/
|
isInString?: true;
|
}
|
/** @deprecated */
|
interface OccurrencesResponse extends Response {
|
body?: OccurrencesResponseItem[];
|
}
|
/**
|
* Get document highlights request; value of command field is
|
* "documentHighlights". Return response giving spans that are relevant
|
* in the file at a given line and column.
|
*/
|
interface DocumentHighlightsRequest extends FileLocationRequest {
|
command: CommandTypes.DocumentHighlights;
|
arguments: DocumentHighlightsRequestArgs;
|
}
|
/**
|
* Span augmented with extra information that denotes the kind of the highlighting to be used for span.
|
*/
|
interface HighlightSpan extends TextSpanWithContext {
|
kind: HighlightSpanKind;
|
}
|
/**
|
* Represents a set of highligh spans for a give name
|
*/
|
interface DocumentHighlightsItem {
|
/**
|
* File containing highlight spans.
|
*/
|
file: string;
|
/**
|
* Spans to highlight in file.
|
*/
|
highlightSpans: HighlightSpan[];
|
}
|
/**
|
* Response for a DocumentHighlightsRequest request.
|
*/
|
interface DocumentHighlightsResponse extends Response {
|
body?: DocumentHighlightsItem[];
|
}
|
/**
|
* Find references request; value of command field is
|
* "references". Return response giving the file locations that
|
* reference the symbol found in file at location line, col.
|
*/
|
interface ReferencesRequest extends FileLocationRequest {
|
command: CommandTypes.References;
|
}
|
interface ReferencesResponseItem extends FileSpanWithContext {
|
/** Text of line containing the reference. Including this
|
* with the response avoids latency of editor loading files
|
* to show text of reference line (the server already has
|
* loaded the referencing files).
|
*/
|
lineText: string;
|
/**
|
* True if reference is a write location, false otherwise.
|
*/
|
isWriteAccess: boolean;
|
/**
|
* True if reference is a definition, false otherwise.
|
*/
|
isDefinition: boolean;
|
}
|
/**
|
* The body of a "references" response message.
|
*/
|
interface ReferencesResponseBody {
|
/**
|
* The file locations referencing the symbol.
|
*/
|
refs: readonly ReferencesResponseItem[];
|
/**
|
* The name of the symbol.
|
*/
|
symbolName: string;
|
/**
|
* The start character offset of the symbol (on the line provided by the references request).
|
*/
|
symbolStartOffset: number;
|
/**
|
* The full display name of the symbol.
|
*/
|
symbolDisplayString: string;
|
}
|
/**
|
* Response to "references" request.
|
*/
|
interface ReferencesResponse extends Response {
|
body?: ReferencesResponseBody;
|
}
|
interface FileReferencesRequest extends FileRequest {
|
command: CommandTypes.FileReferences;
|
}
|
interface FileReferencesResponseBody {
|
/**
|
* The file locations referencing the symbol.
|
*/
|
refs: readonly ReferencesResponseItem[];
|
/**
|
* The name of the symbol.
|
*/
|
symbolName: string;
|
}
|
interface FileReferencesResponse extends Response {
|
body?: FileReferencesResponseBody;
|
}
|
/**
|
* Argument for RenameRequest request.
|
*/
|
interface RenameRequestArgs extends FileLocationRequestArgs {
|
/**
|
* Should text at specified location be found/changed in comments?
|
*/
|
findInComments?: boolean;
|
/**
|
* Should text at specified location be found/changed in strings?
|
*/
|
findInStrings?: boolean;
|
}
|
/**
|
* Rename request; value of command field is "rename". Return
|
* response giving the file locations that reference the symbol
|
* found in file at location line, col. Also return full display
|
* name of the symbol so that client can print it unambiguously.
|
*/
|
interface RenameRequest extends FileLocationRequest {
|
command: CommandTypes.Rename;
|
arguments: RenameRequestArgs;
|
}
|
/**
|
* Information about the item to be renamed.
|
*/
|
type RenameInfo = RenameInfoSuccess | RenameInfoFailure;
|
interface RenameInfoSuccess {
|
/**
|
* True if item can be renamed.
|
*/
|
canRename: true;
|
/**
|
* File or directory to rename.
|
* If set, `getEditsForFileRename` should be called instead of `findRenameLocations`.
|
*/
|
fileToRename?: string;
|
/**
|
* Display name of the item to be renamed.
|
*/
|
displayName: string;
|
/**
|
* Full display name of item to be renamed.
|
*/
|
fullDisplayName: string;
|
/**
|
* The items's kind (such as 'className' or 'parameterName' or plain 'text').
|
*/
|
kind: ScriptElementKind;
|
/**
|
* Optional modifiers for the kind (such as 'public').
|
*/
|
kindModifiers: string;
|
/** Span of text to rename. */
|
triggerSpan: TextSpan;
|
}
|
interface RenameInfoFailure {
|
canRename: false;
|
/**
|
* Error message if item can not be renamed.
|
*/
|
localizedErrorMessage: string;
|
}
|
/**
|
* A group of text spans, all in 'file'.
|
*/
|
interface SpanGroup {
|
/** The file to which the spans apply */
|
file: string;
|
/** The text spans in this group */
|
locs: RenameTextSpan[];
|
}
|
interface RenameTextSpan extends TextSpanWithContext {
|
readonly prefixText?: string;
|
readonly suffixText?: string;
|
}
|
interface RenameResponseBody {
|
/**
|
* Information about the item to be renamed.
|
*/
|
info: RenameInfo;
|
/**
|
* An array of span groups (one per file) that refer to the item to be renamed.
|
*/
|
locs: readonly SpanGroup[];
|
}
|
/**
|
* Rename response message.
|
*/
|
interface RenameResponse extends Response {
|
body?: RenameResponseBody;
|
}
|
/**
|
* Represents a file in external project.
|
* External project is project whose set of files, compilation options and open\close state
|
* is maintained by the client (i.e. if all this data come from .csproj file in Visual Studio).
|
* External project will exist even if all files in it are closed and should be closed explicitly.
|
* If external project includes one or more tsconfig.json/jsconfig.json files then tsserver will
|
* create configured project for every config file but will maintain a link that these projects were created
|
* as a result of opening external project so they should be removed once external project is closed.
|
*/
|
interface ExternalFile {
|
/**
|
* Name of file file
|
*/
|
fileName: string;
|
/**
|
* Script kind of the file
|
*/
|
scriptKind?: ScriptKindName | ts.ScriptKind;
|
/**
|
* Whether file has mixed content (i.e. .cshtml file that combines html markup with C#/JavaScript)
|
*/
|
hasMixedContent?: boolean;
|
/**
|
* Content of the file
|
*/
|
content?: string;
|
}
|
/**
|
* Represent an external project
|
*/
|
interface ExternalProject {
|
/**
|
* Project name
|
*/
|
projectFileName: string;
|
/**
|
* List of root files in project
|
*/
|
rootFiles: ExternalFile[];
|
/**
|
* Compiler options for the project
|
*/
|
options: ExternalProjectCompilerOptions;
|
/**
|
* @deprecated typingOptions. Use typeAcquisition instead
|
*/
|
typingOptions?: TypeAcquisition;
|
/**
|
* Explicitly specified type acquisition for the project
|
*/
|
typeAcquisition?: TypeAcquisition;
|
}
|
interface CompileOnSaveMixin {
|
/**
|
* If compile on save is enabled for the project
|
*/
|
compileOnSave?: boolean;
|
}
|
/**
|
* For external projects, some of the project settings are sent together with
|
* compiler settings.
|
*/
|
type ExternalProjectCompilerOptions = CompilerOptions & CompileOnSaveMixin & WatchOptions;
|
interface FileWithProjectReferenceRedirectInfo {
|
/**
|
* Name of file
|
*/
|
fileName: string;
|
/**
|
* True if the file is primarily included in a referenced project
|
*/
|
isSourceOfProjectReferenceRedirect: boolean;
|
}
|
/**
|
* Represents a set of changes that happen in project
|
*/
|
interface ProjectChanges {
|
/**
|
* List of added files
|
*/
|
added: string[] | FileWithProjectReferenceRedirectInfo[];
|
/**
|
* List of removed files
|
*/
|
removed: string[] | FileWithProjectReferenceRedirectInfo[];
|
/**
|
* List of updated files
|
*/
|
updated: string[] | FileWithProjectReferenceRedirectInfo[];
|
/**
|
* List of files that have had their project reference redirect status updated
|
* Only provided when the synchronizeProjectList request has includeProjectReferenceRedirectInfo set to true
|
*/
|
updatedRedirects?: FileWithProjectReferenceRedirectInfo[];
|
}
|
/**
|
* Information found in a configure request.
|
*/
|
interface ConfigureRequestArguments {
|
/**
|
* Information about the host, for example 'Emacs 24.4' or
|
* 'Sublime Text version 3075'
|
*/
|
hostInfo?: string;
|
/**
|
* If present, tab settings apply only to this file.
|
*/
|
file?: string;
|
/**
|
* The format options to use during formatting and other code editing features.
|
*/
|
formatOptions?: FormatCodeSettings;
|
preferences?: UserPreferences;
|
/**
|
* The host's additional supported .js file extensions
|
*/
|
extraFileExtensions?: FileExtensionInfo[];
|
watchOptions?: WatchOptions;
|
}
|
const enum WatchFileKind {
|
FixedPollingInterval = "FixedPollingInterval",
|
PriorityPollingInterval = "PriorityPollingInterval",
|
DynamicPriorityPolling = "DynamicPriorityPolling",
|
FixedChunkSizePolling = "FixedChunkSizePolling",
|
UseFsEvents = "UseFsEvents",
|
UseFsEventsOnParentDirectory = "UseFsEventsOnParentDirectory"
|
}
|
const enum WatchDirectoryKind {
|
UseFsEvents = "UseFsEvents",
|
FixedPollingInterval = "FixedPollingInterval",
|
DynamicPriorityPolling = "DynamicPriorityPolling",
|
FixedChunkSizePolling = "FixedChunkSizePolling"
|
}
|
const enum PollingWatchKind {
|
FixedInterval = "FixedInterval",
|
PriorityInterval = "PriorityInterval",
|
DynamicPriority = "DynamicPriority",
|
FixedChunkSize = "FixedChunkSize"
|
}
|
interface WatchOptions {
|
watchFile?: WatchFileKind | ts.WatchFileKind;
|
watchDirectory?: WatchDirectoryKind | ts.WatchDirectoryKind;
|
fallbackPolling?: PollingWatchKind | ts.PollingWatchKind;
|
synchronousWatchDirectory?: boolean;
|
excludeDirectories?: string[];
|
excludeFiles?: string[];
|
[option: string]: CompilerOptionsValue | undefined;
|
}
|
/**
|
* Configure request; value of command field is "configure". Specifies
|
* host information, such as host type, tab size, and indent size.
|
*/
|
interface ConfigureRequest extends Request {
|
command: CommandTypes.Configure;
|
arguments: ConfigureRequestArguments;
|
}
|
/**
|
* Response to "configure" request. This is just an acknowledgement, so
|
* no body field is required.
|
*/
|
interface ConfigureResponse extends Response {
|
}
|
interface ConfigurePluginRequestArguments {
|
pluginName: string;
|
configuration: any;
|
}
|
interface ConfigurePluginRequest extends Request {
|
command: CommandTypes.ConfigurePlugin;
|
arguments: ConfigurePluginRequestArguments;
|
}
|
interface ConfigurePluginResponse extends Response {
|
}
|
interface SelectionRangeRequest extends FileRequest {
|
command: CommandTypes.SelectionRange;
|
arguments: SelectionRangeRequestArgs;
|
}
|
interface SelectionRangeRequestArgs extends FileRequestArgs {
|
locations: Location[];
|
}
|
interface SelectionRangeResponse extends Response {
|
body?: SelectionRange[];
|
}
|
interface SelectionRange {
|
textSpan: TextSpan;
|
parent?: SelectionRange;
|
}
|
interface ToggleLineCommentRequest extends FileRequest {
|
command: CommandTypes.ToggleLineComment;
|
arguments: FileRangeRequestArgs;
|
}
|
interface ToggleMultilineCommentRequest extends FileRequest {
|
command: CommandTypes.ToggleMultilineComment;
|
arguments: FileRangeRequestArgs;
|
}
|
interface CommentSelectionRequest extends FileRequest {
|
command: CommandTypes.CommentSelection;
|
arguments: FileRangeRequestArgs;
|
}
|
interface UncommentSelectionRequest extends FileRequest {
|
command: CommandTypes.UncommentSelection;
|
arguments: FileRangeRequestArgs;
|
}
|
/**
|
* Information found in an "open" request.
|
*/
|
interface OpenRequestArgs extends FileRequestArgs {
|
/**
|
* Used when a version of the file content is known to be more up to date than the one on disk.
|
* Then the known content will be used upon opening instead of the disk copy
|
*/
|
fileContent?: string;
|
/**
|
* Used to specify the script kind of the file explicitly. It could be one of the following:
|
* "TS", "JS", "TSX", "JSX"
|
*/
|
scriptKindName?: ScriptKindName;
|
/**
|
* Used to limit the searching for project config file. If given the searching will stop at this
|
* root path; otherwise it will go all the way up to the dist root path.
|
*/
|
projectRootPath?: string;
|
}
|
type ScriptKindName = "TS" | "JS" | "TSX" | "JSX";
|
/**
|
* Open request; value of command field is "open". Notify the
|
* server that the client has file open. The server will not
|
* monitor the filesystem for changes in this file and will assume
|
* that the client is updating the server (using the change and/or
|
* reload messages) when the file changes. Server does not currently
|
* send a response to an open request.
|
*/
|
interface OpenRequest extends Request {
|
command: CommandTypes.Open;
|
arguments: OpenRequestArgs;
|
}
|
/**
|
* Request to open or update external project
|
*/
|
interface OpenExternalProjectRequest extends Request {
|
command: CommandTypes.OpenExternalProject;
|
arguments: OpenExternalProjectArgs;
|
}
|
/**
|
* Arguments to OpenExternalProjectRequest request
|
*/
|
type OpenExternalProjectArgs = ExternalProject;
|
/**
|
* Request to open multiple external projects
|
*/
|
interface OpenExternalProjectsRequest extends Request {
|
command: CommandTypes.OpenExternalProjects;
|
arguments: OpenExternalProjectsArgs;
|
}
|
/**
|
* Arguments to OpenExternalProjectsRequest
|
*/
|
interface OpenExternalProjectsArgs {
|
/**
|
* List of external projects to open or update
|
*/
|
projects: ExternalProject[];
|
}
|
/**
|
* Response to OpenExternalProjectRequest request. This is just an acknowledgement, so
|
* no body field is required.
|
*/
|
interface OpenExternalProjectResponse extends Response {
|
}
|
/**
|
* Response to OpenExternalProjectsRequest request. This is just an acknowledgement, so
|
* no body field is required.
|
*/
|
interface OpenExternalProjectsResponse extends Response {
|
}
|
/**
|
* Request to close external project.
|
*/
|
interface CloseExternalProjectRequest extends Request {
|
command: CommandTypes.CloseExternalProject;
|
arguments: CloseExternalProjectRequestArgs;
|
}
|
/**
|
* Arguments to CloseExternalProjectRequest request
|
*/
|
interface CloseExternalProjectRequestArgs {
|
/**
|
* Name of the project to close
|
*/
|
projectFileName: string;
|
}
|
/**
|
* Response to CloseExternalProjectRequest request. This is just an acknowledgement, so
|
* no body field is required.
|
*/
|
interface CloseExternalProjectResponse extends Response {
|
}
|
/**
|
* Request to synchronize list of open files with the client
|
*/
|
interface UpdateOpenRequest extends Request {
|
command: CommandTypes.UpdateOpen;
|
arguments: UpdateOpenRequestArgs;
|
}
|
/**
|
* Arguments to UpdateOpenRequest
|
*/
|
interface UpdateOpenRequestArgs {
|
/**
|
* List of newly open files
|
*/
|
openFiles?: OpenRequestArgs[];
|
/**
|
* List of open files files that were changes
|
*/
|
changedFiles?: FileCodeEdits[];
|
/**
|
* List of files that were closed
|
*/
|
closedFiles?: string[];
|
}
|
/**
|
* External projects have a typeAcquisition option so they need to be added separately to compiler options for inferred projects.
|
*/
|
type InferredProjectCompilerOptions = ExternalProjectCompilerOptions & TypeAcquisition;
|
/**
|
* Request to set compiler options for inferred projects.
|
* External projects are opened / closed explicitly.
|
* Configured projects are opened when user opens loose file that has 'tsconfig.json' or 'jsconfig.json' anywhere in one of containing folders.
|
* This configuration file will be used to obtain a list of files and configuration settings for the project.
|
* Inferred projects are created when user opens a loose file that is not the part of external project
|
* or configured project and will contain only open file and transitive closure of referenced files if 'useOneInferredProject' is false,
|
* or all open loose files and its transitive closure of referenced files if 'useOneInferredProject' is true.
|
*/
|
interface SetCompilerOptionsForInferredProjectsRequest extends Request {
|
command: CommandTypes.CompilerOptionsForInferredProjects;
|
arguments: SetCompilerOptionsForInferredProjectsArgs;
|
}
|
/**
|
* Argument for SetCompilerOptionsForInferredProjectsRequest request.
|
*/
|
interface SetCompilerOptionsForInferredProjectsArgs {
|
/**
|
* Compiler options to be used with inferred projects.
|
*/
|
options: InferredProjectCompilerOptions;
|
/**
|
* Specifies the project root path used to scope compiler options.
|
* It is an error to provide this property if the server has not been started with
|
* `useInferredProjectPerProjectRoot` enabled.
|
*/
|
projectRootPath?: string;
|
}
|
/**
|
* Response to SetCompilerOptionsForInferredProjectsResponse request. This is just an acknowledgement, so
|
* no body field is required.
|
*/
|
interface SetCompilerOptionsForInferredProjectsResponse extends Response {
|
}
|
/**
|
* Exit request; value of command field is "exit". Ask the server process
|
* to exit.
|
*/
|
interface ExitRequest extends Request {
|
command: CommandTypes.Exit;
|
}
|
/**
|
* Close request; value of command field is "close". Notify the
|
* server that the client has closed a previously open file. If
|
* file is still referenced by open files, the server will resume
|
* monitoring the filesystem for changes to file. Server does not
|
* currently send a response to a close request.
|
*/
|
interface CloseRequest extends FileRequest {
|
command: CommandTypes.Close;
|
}
|
/**
|
* Request to obtain the list of files that should be regenerated if target file is recompiled.
|
* NOTE: this us query-only operation and does not generate any output on disk.
|
*/
|
interface CompileOnSaveAffectedFileListRequest extends FileRequest {
|
command: CommandTypes.CompileOnSaveAffectedFileList;
|
}
|
/**
|
* Contains a list of files that should be regenerated in a project
|
*/
|
interface CompileOnSaveAffectedFileListSingleProject {
|
/**
|
* Project name
|
*/
|
projectFileName: string;
|
/**
|
* List of files names that should be recompiled
|
*/
|
fileNames: string[];
|
/**
|
* true if project uses outFile or out compiler option
|
*/
|
projectUsesOutFile: boolean;
|
}
|
/**
|
* Response for CompileOnSaveAffectedFileListRequest request;
|
*/
|
interface CompileOnSaveAffectedFileListResponse extends Response {
|
body: CompileOnSaveAffectedFileListSingleProject[];
|
}
|
/**
|
* Request to recompile the file. All generated outputs (.js, .d.ts or .js.map files) is written on disk.
|
*/
|
interface CompileOnSaveEmitFileRequest extends FileRequest {
|
command: CommandTypes.CompileOnSaveEmitFile;
|
arguments: CompileOnSaveEmitFileRequestArgs;
|
}
|
/**
|
* Arguments for CompileOnSaveEmitFileRequest
|
*/
|
interface CompileOnSaveEmitFileRequestArgs extends FileRequestArgs {
|
/**
|
* if true - then file should be recompiled even if it does not have any changes.
|
*/
|
forced?: boolean;
|
includeLinePosition?: boolean;
|
/** if true - return response as object with emitSkipped and diagnostics */
|
richResponse?: boolean;
|
}
|
interface CompileOnSaveEmitFileResponse extends Response {
|
body: boolean | EmitResult;
|
}
|
interface EmitResult {
|
emitSkipped: boolean;
|
diagnostics: Diagnostic[] | DiagnosticWithLinePosition[];
|
}
|
/**
|
* Quickinfo request; value of command field is
|
* "quickinfo". Return response giving a quick type and
|
* documentation string for the symbol found in file at location
|
* line, col.
|
*/
|
interface QuickInfoRequest extends FileLocationRequest {
|
command: CommandTypes.Quickinfo;
|
arguments: FileLocationRequestArgs;
|
}
|
/**
|
* Body of QuickInfoResponse.
|
*/
|
interface QuickInfoResponseBody {
|
/**
|
* The symbol's kind (such as 'className' or 'parameterName' or plain 'text').
|
*/
|
kind: ScriptElementKind;
|
/**
|
* Optional modifiers for the kind (such as 'public').
|
*/
|
kindModifiers: string;
|
/**
|
* Starting file location of symbol.
|
*/
|
start: Location;
|
/**
|
* One past last character of symbol.
|
*/
|
end: Location;
|
/**
|
* Type and kind of symbol.
|
*/
|
displayString: string;
|
/**
|
* Documentation associated with symbol.
|
* Display parts when UserPreferences.displayPartsForJSDoc is true, flattened to string otherwise.
|
*/
|
documentation: string | SymbolDisplayPart[];
|
/**
|
* JSDoc tags associated with symbol.
|
*/
|
tags: JSDocTagInfo[];
|
}
|
/**
|
* Quickinfo response message.
|
*/
|
interface QuickInfoResponse extends Response {
|
body?: QuickInfoResponseBody;
|
}
|
/**
|
* Arguments for format messages.
|
*/
|
interface FormatRequestArgs extends FileLocationRequestArgs {
|
/**
|
* Last line of range for which to format text in file.
|
*/
|
endLine: number;
|
/**
|
* Character offset on last line of range for which to format text in file.
|
*/
|
endOffset: number;
|
/**
|
* Format options to be used.
|
*/
|
options?: FormatCodeSettings;
|
}
|
/**
|
* Format request; value of command field is "format". Return
|
* response giving zero or more edit instructions. The edit
|
* instructions will be sorted in file order. Applying the edit
|
* instructions in reverse to file will result in correctly
|
* reformatted text.
|
*/
|
interface FormatRequest extends FileLocationRequest {
|
command: CommandTypes.Format;
|
arguments: FormatRequestArgs;
|
}
|
/**
|
* Object found in response messages defining an editing
|
* instruction for a span of text in source code. The effect of
|
* this instruction is to replace the text starting at start and
|
* ending one character before end with newText. For an insertion,
|
* the text span is empty. For a deletion, newText is empty.
|
*/
|
interface CodeEdit {
|
/**
|
* First character of the text span to edit.
|
*/
|
start: Location;
|
/**
|
* One character past last character of the text span to edit.
|
*/
|
end: Location;
|
/**
|
* Replace the span defined above with this string (may be
|
* the empty string).
|
*/
|
newText: string;
|
}
|
interface FileCodeEdits {
|
fileName: string;
|
textChanges: CodeEdit[];
|
}
|
interface CodeFixResponse extends Response {
|
/** The code actions that are available */
|
body?: CodeFixAction[];
|
}
|
interface CodeAction {
|
/** Description of the code action to display in the UI of the editor */
|
description: string;
|
/** Text changes to apply to each file as part of the code action */
|
changes: FileCodeEdits[];
|
/** A command is an opaque object that should be passed to `ApplyCodeActionCommandRequestArgs` without modification. */
|
commands?: {}[];
|
}
|
interface CombinedCodeActions {
|
changes: readonly FileCodeEdits[];
|
commands?: readonly {}[];
|
}
|
interface CodeFixAction extends CodeAction {
|
/** Short name to identify the fix, for use by telemetry. */
|
fixName: string;
|
/**
|
* If present, one may call 'getCombinedCodeFix' with this fixId.
|
* This may be omitted to indicate that the code fix can't be applied in a group.
|
*/
|
fixId?: {};
|
/** Should be present if and only if 'fixId' is. */
|
fixAllDescription?: string;
|
}
|
/**
|
* Format and format on key response message.
|
*/
|
interface FormatResponse extends Response {
|
body?: CodeEdit[];
|
}
|
/**
|
* Arguments for format on key messages.
|
*/
|
interface FormatOnKeyRequestArgs extends FileLocationRequestArgs {
|
/**
|
* Key pressed (';', '\n', or '}').
|
*/
|
key: string;
|
options?: FormatCodeSettings;
|
}
|
/**
|
* Format on key request; value of command field is
|
* "formatonkey". Given file location and key typed (as string),
|
* return response giving zero or more edit instructions. The
|
* edit instructions will be sorted in file order. Applying the
|
* edit instructions in reverse to file will result in correctly
|
* reformatted text.
|
*/
|
interface FormatOnKeyRequest extends FileLocationRequest {
|
command: CommandTypes.Formatonkey;
|
arguments: FormatOnKeyRequestArgs;
|
}
|
type CompletionsTriggerCharacter = "." | '"' | "'" | "`" | "/" | "@" | "<" | "#" | " ";
|
const enum CompletionTriggerKind {
|
/** Completion was triggered by typing an identifier, manual invocation (e.g Ctrl+Space) or via API. */
|
Invoked = 1,
|
/** Completion was triggered by a trigger character. */
|
TriggerCharacter = 2,
|
/** Completion was re-triggered as the current completion list is incomplete. */
|
TriggerForIncompleteCompletions = 3
|
}
|
/**
|
* Arguments for completions messages.
|
*/
|
interface CompletionsRequestArgs extends FileLocationRequestArgs {
|
/**
|
* Optional prefix to apply to possible completions.
|
*/
|
prefix?: string;
|
/**
|
* Character that was responsible for triggering completion.
|
* Should be `undefined` if a user manually requested completion.
|
*/
|
triggerCharacter?: CompletionsTriggerCharacter;
|
triggerKind?: CompletionTriggerKind;
|
/**
|
* @deprecated Use UserPreferences.includeCompletionsForModuleExports
|
*/
|
includeExternalModuleExports?: boolean;
|
/**
|
* @deprecated Use UserPreferences.includeCompletionsWithInsertText
|
*/
|
includeInsertTextCompletions?: boolean;
|
}
|
/**
|
* Completions request; value of command field is "completions".
|
* Given a file location (file, line, col) and a prefix (which may
|
* be the empty string), return the possible completions that
|
* begin with prefix.
|
*/
|
interface CompletionsRequest extends FileLocationRequest {
|
command: CommandTypes.Completions | CommandTypes.CompletionInfo;
|
arguments: CompletionsRequestArgs;
|
}
|
/**
|
* Arguments for completion details request.
|
*/
|
interface CompletionDetailsRequestArgs extends FileLocationRequestArgs {
|
/**
|
* Names of one or more entries for which to obtain details.
|
*/
|
entryNames: (string | CompletionEntryIdentifier)[];
|
}
|
interface CompletionEntryIdentifier {
|
name: string;
|
source?: string;
|
data?: unknown;
|
}
|
/**
|
* Completion entry details request; value of command field is
|
* "completionEntryDetails". Given a file location (file, line,
|
* col) and an array of completion entry names return more
|
* detailed information for each completion entry.
|
*/
|
interface CompletionDetailsRequest extends FileLocationRequest {
|
command: CommandTypes.CompletionDetails;
|
arguments: CompletionDetailsRequestArgs;
|
}
|
/**
|
* Part of a symbol description.
|
*/
|
interface SymbolDisplayPart {
|
/**
|
* Text of an item describing the symbol.
|
*/
|
text: string;
|
/**
|
* The symbol's kind (such as 'className' or 'parameterName' or plain 'text').
|
*/
|
kind: string;
|
}
|
/** A part of a symbol description that links from a jsdoc @link tag to a declaration */
|
interface JSDocLinkDisplayPart extends SymbolDisplayPart {
|
/** The location of the declaration that the @link tag links to. */
|
target: FileSpan;
|
}
|
/**
|
* An item found in a completion response.
|
*/
|
interface CompletionEntry {
|
/**
|
* The symbol's name.
|
*/
|
name: string;
|
/**
|
* The symbol's kind (such as 'className' or 'parameterName').
|
*/
|
kind: ScriptElementKind;
|
/**
|
* Optional modifiers for the kind (such as 'public').
|
*/
|
kindModifiers?: string;
|
/**
|
* A string that is used for comparing completion items so that they can be ordered. This
|
* is often the same as the name but may be different in certain circumstances.
|
*/
|
sortText: string;
|
/**
|
* Text to insert instead of `name`.
|
* This is used to support bracketed completions; If `name` might be "a-b" but `insertText` would be `["a-b"]`,
|
* coupled with `replacementSpan` to replace a dotted access with a bracket access.
|
*/
|
insertText?: string;
|
/**
|
* `insertText` should be interpreted as a snippet if true.
|
*/
|
isSnippet?: true;
|
/**
|
* An optional span that indicates the text to be replaced by this completion item.
|
* If present, this span should be used instead of the default one.
|
* It will be set if the required span differs from the one generated by the default replacement behavior.
|
*/
|
replacementSpan?: TextSpan;
|
/**
|
* Indicates whether commiting this completion entry will require additional code actions to be
|
* made to avoid errors. The CompletionEntryDetails will have these actions.
|
*/
|
hasAction?: true;
|
/**
|
* Identifier (not necessarily human-readable) identifying where this completion came from.
|
*/
|
source?: string;
|
/**
|
* Human-readable description of the `source`.
|
*/
|
sourceDisplay?: SymbolDisplayPart[];
|
/**
|
* If true, this completion should be highlighted as recommended. There will only be one of these.
|
* This will be set when we know the user should write an expression with a certain type and that type is an enum or constructable class.
|
* Then either that enum/class or a namespace containing it will be the recommended symbol.
|
*/
|
isRecommended?: true;
|
/**
|
* If true, this completion was generated from traversing the name table of an unchecked JS file,
|
* and therefore may not be accurate.
|
*/
|
isFromUncheckedFile?: true;
|
/**
|
* If true, this completion was for an auto-import of a module not yet in the program, but listed
|
* in the project package.json. Used for telemetry reporting.
|
*/
|
isPackageJsonImport?: true;
|
/**
|
* If true, this completion was an auto-import-style completion of an import statement (i.e., the
|
* module specifier was inserted along with the imported identifier). Used for telemetry reporting.
|
*/
|
isImportStatementCompletion?: true;
|
/**
|
* A property to be sent back to TS Server in the CompletionDetailsRequest, along with `name`,
|
* that allows TS Server to look up the symbol represented by the completion item, disambiguating
|
* items with the same name.
|
*/
|
data?: unknown;
|
}
|
/**
|
* Additional completion entry details, available on demand
|
*/
|
interface CompletionEntryDetails {
|
/**
|
* The symbol's name.
|
*/
|
name: string;
|
/**
|
* The symbol's kind (such as 'className' or 'parameterName').
|
*/
|
kind: ScriptElementKind;
|
/**
|
* Optional modifiers for the kind (such as 'public').
|
*/
|
kindModifiers: string;
|
/**
|
* Display parts of the symbol (similar to quick info).
|
*/
|
displayParts: SymbolDisplayPart[];
|
/**
|
* Documentation strings for the symbol.
|
*/
|
documentation?: SymbolDisplayPart[];
|
/**
|
* JSDoc tags for the symbol.
|
*/
|
tags?: JSDocTagInfo[];
|
/**
|
* The associated code actions for this entry
|
*/
|
codeActions?: CodeAction[];
|
/**
|
* @deprecated Use `sourceDisplay` instead.
|
*/
|
source?: SymbolDisplayPart[];
|
/**
|
* Human-readable description of the `source` from the CompletionEntry.
|
*/
|
sourceDisplay?: SymbolDisplayPart[];
|
}
|
/** @deprecated Prefer CompletionInfoResponse, which supports several top-level fields in addition to the array of entries. */
|
interface CompletionsResponse extends Response {
|
body?: CompletionEntry[];
|
}
|
interface CompletionInfoResponse extends Response {
|
body?: CompletionInfo;
|
}
|
interface CompletionInfo {
|
readonly isGlobalCompletion: boolean;
|
readonly isMemberCompletion: boolean;
|
readonly isNewIdentifierLocation: boolean;
|
/**
|
* In the absence of `CompletionEntry["replacementSpan"]`, the editor may choose whether to use
|
* this span or its default one. If `CompletionEntry["replacementSpan"]` is defined, that span
|
* must be used to commit that completion entry.
|
*/
|
readonly optionalReplacementSpan?: TextSpan;
|
readonly isIncomplete?: boolean;
|
readonly entries: readonly CompletionEntry[];
|
}
|
interface CompletionDetailsResponse extends Response {
|
body?: CompletionEntryDetails[];
|
}
|
/**
|
* Signature help information for a single parameter
|
*/
|
interface SignatureHelpParameter {
|
/**
|
* The parameter's name
|
*/
|
name: string;
|
/**
|
* Documentation of the parameter.
|
*/
|
documentation: SymbolDisplayPart[];
|
/**
|
* Display parts of the parameter.
|
*/
|
displayParts: SymbolDisplayPart[];
|
/**
|
* Whether the parameter is optional or not.
|
*/
|
isOptional: boolean;
|
}
|
/**
|
* Represents a single signature to show in signature help.
|
*/
|
interface SignatureHelpItem {
|
/**
|
* Whether the signature accepts a variable number of arguments.
|
*/
|
isVariadic: boolean;
|
/**
|
* The prefix display parts.
|
*/
|
prefixDisplayParts: SymbolDisplayPart[];
|
/**
|
* The suffix display parts.
|
*/
|
suffixDisplayParts: SymbolDisplayPart[];
|
/**
|
* The separator display parts.
|
*/
|
separatorDisplayParts: SymbolDisplayPart[];
|
/**
|
* The signature helps items for the parameters.
|
*/
|
parameters: SignatureHelpParameter[];
|
/**
|
* The signature's documentation
|
*/
|
documentation: SymbolDisplayPart[];
|
/**
|
* The signature's JSDoc tags
|
*/
|
tags: JSDocTagInfo[];
|
}
|
/**
|
* Signature help items found in the response of a signature help request.
|
*/
|
interface SignatureHelpItems {
|
/**
|
* The signature help items.
|
*/
|
items: SignatureHelpItem[];
|
/**
|
* The span for which signature help should appear on a signature
|
*/
|
applicableSpan: TextSpan;
|
/**
|
* The item selected in the set of available help items.
|
*/
|
selectedItemIndex: number;
|
/**
|
* The argument selected in the set of parameters.
|
*/
|
argumentIndex: number;
|
/**
|
* The argument count
|
*/
|
argumentCount: number;
|
}
|
type SignatureHelpTriggerCharacter = "," | "(" | "<";
|
type SignatureHelpRetriggerCharacter = SignatureHelpTriggerCharacter | ")";
|
/**
|
* Arguments of a signature help request.
|
*/
|
interface SignatureHelpRequestArgs extends FileLocationRequestArgs {
|
/**
|
* Reason why signature help was invoked.
|
* See each individual possible
|
*/
|
triggerReason?: SignatureHelpTriggerReason;
|
}
|
type SignatureHelpTriggerReason = SignatureHelpInvokedReason | SignatureHelpCharacterTypedReason | SignatureHelpRetriggeredReason;
|
/**
|
* Signals that the user manually requested signature help.
|
* The language service will unconditionally attempt to provide a result.
|
*/
|
interface SignatureHelpInvokedReason {
|
kind: "invoked";
|
triggerCharacter?: undefined;
|
}
|
/**
|
* Signals that the signature help request came from a user typing a character.
|
* Depending on the character and the syntactic context, the request may or may not be served a result.
|
*/
|
interface SignatureHelpCharacterTypedReason {
|
kind: "characterTyped";
|
/**
|
* Character that was responsible for triggering signature help.
|
*/
|
triggerCharacter: SignatureHelpTriggerCharacter;
|
}
|
/**
|
* Signals that this signature help request came from typing a character or moving the cursor.
|
* This should only occur if a signature help session was already active and the editor needs to see if it should adjust.
|
* The language service will unconditionally attempt to provide a result.
|
* `triggerCharacter` can be `undefined` for a retrigger caused by a cursor move.
|
*/
|
interface SignatureHelpRetriggeredReason {
|
kind: "retrigger";
|
/**
|
* Character that was responsible for triggering signature help.
|
*/
|
triggerCharacter?: SignatureHelpRetriggerCharacter;
|
}
|
/**
|
* Signature help request; value of command field is "signatureHelp".
|
* Given a file location (file, line, col), return the signature
|
* help.
|
*/
|
interface SignatureHelpRequest extends FileLocationRequest {
|
command: CommandTypes.SignatureHelp;
|
arguments: SignatureHelpRequestArgs;
|
}
|
/**
|
* Response object for a SignatureHelpRequest.
|
*/
|
interface SignatureHelpResponse extends Response {
|
body?: SignatureHelpItems;
|
}
|
type InlayHintKind = "Type" | "Parameter" | "Enum";
|
interface InlayHintsRequestArgs extends FileRequestArgs {
|
/**
|
* Start position of the span.
|
*/
|
start: number;
|
/**
|
* Length of the span.
|
*/
|
length: number;
|
}
|
interface InlayHintsRequest extends Request {
|
command: CommandTypes.ProvideInlayHints;
|
arguments: InlayHintsRequestArgs;
|
}
|
interface InlayHintItem {
|
text: string;
|
position: Location;
|
kind: InlayHintKind;
|
whitespaceBefore?: boolean;
|
whitespaceAfter?: boolean;
|
}
|
interface InlayHintsResponse extends Response {
|
body?: InlayHintItem[];
|
}
|
/**
|
* Synchronous request for semantic diagnostics of one file.
|
*/
|
interface SemanticDiagnosticsSyncRequest extends FileRequest {
|
command: CommandTypes.SemanticDiagnosticsSync;
|
arguments: SemanticDiagnosticsSyncRequestArgs;
|
}
|
interface SemanticDiagnosticsSyncRequestArgs extends FileRequestArgs {
|
includeLinePosition?: boolean;
|
}
|
/**
|
* Response object for synchronous sematic diagnostics request.
|
*/
|
interface SemanticDiagnosticsSyncResponse extends Response {
|
body?: Diagnostic[] | DiagnosticWithLinePosition[];
|
}
|
interface SuggestionDiagnosticsSyncRequest extends FileRequest {
|
command: CommandTypes.SuggestionDiagnosticsSync;
|
arguments: SuggestionDiagnosticsSyncRequestArgs;
|
}
|
type SuggestionDiagnosticsSyncRequestArgs = SemanticDiagnosticsSyncRequestArgs;
|
type SuggestionDiagnosticsSyncResponse = SemanticDiagnosticsSyncResponse;
|
/**
|
* Synchronous request for syntactic diagnostics of one file.
|
*/
|
interface SyntacticDiagnosticsSyncRequest extends FileRequest {
|
command: CommandTypes.SyntacticDiagnosticsSync;
|
arguments: SyntacticDiagnosticsSyncRequestArgs;
|
}
|
interface SyntacticDiagnosticsSyncRequestArgs extends FileRequestArgs {
|
includeLinePosition?: boolean;
|
}
|
/**
|
* Response object for synchronous syntactic diagnostics request.
|
*/
|
interface SyntacticDiagnosticsSyncResponse extends Response {
|
body?: Diagnostic[] | DiagnosticWithLinePosition[];
|
}
|
/**
|
* Arguments for GeterrForProject request.
|
*/
|
interface GeterrForProjectRequestArgs {
|
/**
|
* the file requesting project error list
|
*/
|
file: string;
|
/**
|
* Delay in milliseconds to wait before starting to compute
|
* errors for the files in the file list
|
*/
|
delay: number;
|
}
|
/**
|
* GeterrForProjectRequest request; value of command field is
|
* "geterrForProject". It works similarly with 'Geterr', only
|
* it request for every file in this project.
|
*/
|
interface GeterrForProjectRequest extends Request {
|
command: CommandTypes.GeterrForProject;
|
arguments: GeterrForProjectRequestArgs;
|
}
|
/**
|
* Arguments for geterr messages.
|
*/
|
interface GeterrRequestArgs {
|
/**
|
* List of file names for which to compute compiler errors.
|
* The files will be checked in list order.
|
*/
|
files: string[];
|
/**
|
* Delay in milliseconds to wait before starting to compute
|
* errors for the files in the file list
|
*/
|
delay: number;
|
}
|
/**
|
* Geterr request; value of command field is "geterr". Wait for
|
* delay milliseconds and then, if during the wait no change or
|
* reload messages have arrived for the first file in the files
|
* list, get the syntactic errors for the file, field requests,
|
* and then get the semantic errors for the file. Repeat with a
|
* smaller delay for each subsequent file on the files list. Best
|
* practice for an editor is to send a file list containing each
|
* file that is currently visible, in most-recently-used order.
|
*/
|
interface GeterrRequest extends Request {
|
command: CommandTypes.Geterr;
|
arguments: GeterrRequestArgs;
|
}
|
type RequestCompletedEventName = "requestCompleted";
|
/**
|
* Event that is sent when server have finished processing request with specified id.
|
*/
|
interface RequestCompletedEvent extends Event {
|
event: RequestCompletedEventName;
|
body: RequestCompletedEventBody;
|
}
|
interface RequestCompletedEventBody {
|
request_seq: number;
|
}
|
/**
|
* Item of diagnostic information found in a DiagnosticEvent message.
|
*/
|
interface Diagnostic {
|
/**
|
* Starting file location at which text applies.
|
*/
|
start: Location;
|
/**
|
* The last file location at which the text applies.
|
*/
|
end: Location;
|
/**
|
* Text of diagnostic message.
|
*/
|
text: string;
|
/**
|
* The category of the diagnostic message, e.g. "error", "warning", or "suggestion".
|
*/
|
category: string;
|
reportsUnnecessary?: {};
|
reportsDeprecated?: {};
|
/**
|
* Any related spans the diagnostic may have, such as other locations relevant to an error, such as declarartion sites
|
*/
|
relatedInformation?: DiagnosticRelatedInformation[];
|
/**
|
* The error code of the diagnostic message.
|
*/
|
code?: number;
|
/**
|
* The name of the plugin reporting the message.
|
*/
|
source?: string;
|
}
|
interface DiagnosticWithFileName extends Diagnostic {
|
/**
|
* Name of the file the diagnostic is in
|
*/
|
fileName: string;
|
}
|
/**
|
* Represents additional spans returned with a diagnostic which are relevant to it
|
*/
|
interface DiagnosticRelatedInformation {
|
/**
|
* The category of the related information message, e.g. "error", "warning", or "suggestion".
|
*/
|
category: string;
|
/**
|
* The code used ot identify the related information
|
*/
|
code: number;
|
/**
|
* Text of related or additional information.
|
*/
|
message: string;
|
/**
|
* Associated location
|
*/
|
span?: FileSpan;
|
}
|
interface DiagnosticEventBody {
|
/**
|
* The file for which diagnostic information is reported.
|
*/
|
file: string;
|
/**
|
* An array of diagnostic information items.
|
*/
|
diagnostics: Diagnostic[];
|
}
|
type DiagnosticEventKind = "semanticDiag" | "syntaxDiag" | "suggestionDiag";
|
/**
|
* Event message for DiagnosticEventKind event types.
|
* These events provide syntactic and semantic errors for a file.
|
*/
|
interface DiagnosticEvent extends Event {
|
body?: DiagnosticEventBody;
|
event: DiagnosticEventKind;
|
}
|
interface ConfigFileDiagnosticEventBody {
|
/**
|
* The file which trigged the searching and error-checking of the config file
|
*/
|
triggerFile: string;
|
/**
|
* The name of the found config file.
|
*/
|
configFile: string;
|
/**
|
* An arry of diagnostic information items for the found config file.
|
*/
|
diagnostics: DiagnosticWithFileName[];
|
}
|
/**
|
* Event message for "configFileDiag" event type.
|
* This event provides errors for a found config file.
|
*/
|
interface ConfigFileDiagnosticEvent extends Event {
|
body?: ConfigFileDiagnosticEventBody;
|
event: "configFileDiag";
|
}
|
type ProjectLanguageServiceStateEventName = "projectLanguageServiceState";
|
interface ProjectLanguageServiceStateEvent extends Event {
|
event: ProjectLanguageServiceStateEventName;
|
body?: ProjectLanguageServiceStateEventBody;
|
}
|
interface ProjectLanguageServiceStateEventBody {
|
/**
|
* Project name that has changes in the state of language service.
|
* For configured projects this will be the config file path.
|
* For external projects this will be the name of the projects specified when project was open.
|
* For inferred projects this event is not raised.
|
*/
|
projectName: string;
|
/**
|
* True if language service state switched from disabled to enabled
|
* and false otherwise.
|
*/
|
languageServiceEnabled: boolean;
|
}
|
type ProjectsUpdatedInBackgroundEventName = "projectsUpdatedInBackground";
|
interface ProjectsUpdatedInBackgroundEvent extends Event {
|
event: ProjectsUpdatedInBackgroundEventName;
|
body: ProjectsUpdatedInBackgroundEventBody;
|
}
|
interface ProjectsUpdatedInBackgroundEventBody {
|
/**
|
* Current set of open files
|
*/
|
openFiles: string[];
|
}
|
type ProjectLoadingStartEventName = "projectLoadingStart";
|
interface ProjectLoadingStartEvent extends Event {
|
event: ProjectLoadingStartEventName;
|
body: ProjectLoadingStartEventBody;
|
}
|
interface ProjectLoadingStartEventBody {
|
/** name of the project */
|
projectName: string;
|
/** reason for loading */
|
reason: string;
|
}
|
type ProjectLoadingFinishEventName = "projectLoadingFinish";
|
interface ProjectLoadingFinishEvent extends Event {
|
event: ProjectLoadingFinishEventName;
|
body: ProjectLoadingFinishEventBody;
|
}
|
interface ProjectLoadingFinishEventBody {
|
/** name of the project */
|
projectName: string;
|
}
|
type SurveyReadyEventName = "surveyReady";
|
interface SurveyReadyEvent extends Event {
|
event: SurveyReadyEventName;
|
body: SurveyReadyEventBody;
|
}
|
interface SurveyReadyEventBody {
|
/** Name of the survey. This is an internal machine- and programmer-friendly name */
|
surveyId: string;
|
}
|
type LargeFileReferencedEventName = "largeFileReferenced";
|
interface LargeFileReferencedEvent extends Event {
|
event: LargeFileReferencedEventName;
|
body: LargeFileReferencedEventBody;
|
}
|
interface LargeFileReferencedEventBody {
|
/**
|
* name of the large file being loaded
|
*/
|
file: string;
|
/**
|
* size of the file
|
*/
|
fileSize: number;
|
/**
|
* max file size allowed on the server
|
*/
|
maxFileSize: number;
|
}
|
/**
|
* Arguments for reload request.
|
*/
|
interface ReloadRequestArgs extends FileRequestArgs {
|
/**
|
* Name of temporary file from which to reload file
|
* contents. May be same as file.
|
*/
|
tmpfile: string;
|
}
|
/**
|
* Reload request message; value of command field is "reload".
|
* Reload contents of file with name given by the 'file' argument
|
* from temporary file with name given by the 'tmpfile' argument.
|
* The two names can be identical.
|
*/
|
interface ReloadRequest extends FileRequest {
|
command: CommandTypes.Reload;
|
arguments: ReloadRequestArgs;
|
}
|
/**
|
* Response to "reload" request. This is just an acknowledgement, so
|
* no body field is required.
|
*/
|
interface ReloadResponse extends Response {
|
}
|
/**
|
* Arguments for saveto request.
|
*/
|
interface SavetoRequestArgs extends FileRequestArgs {
|
/**
|
* Name of temporary file into which to save server's view of
|
* file contents.
|
*/
|
tmpfile: string;
|
}
|
/**
|
* Saveto request message; value of command field is "saveto".
|
* For debugging purposes, save to a temporaryfile (named by
|
* argument 'tmpfile') the contents of file named by argument
|
* 'file'. The server does not currently send a response to a
|
* "saveto" request.
|
*/
|
interface SavetoRequest extends FileRequest {
|
command: CommandTypes.Saveto;
|
arguments: SavetoRequestArgs;
|
}
|
/**
|
* Arguments for navto request message.
|
*/
|
interface NavtoRequestArgs {
|
/**
|
* Search term to navigate to from current location; term can
|
* be '.*' or an identifier prefix.
|
*/
|
searchValue: string;
|
/**
|
* Optional limit on the number of items to return.
|
*/
|
maxResultCount?: number;
|
/**
|
* The file for the request (absolute pathname required).
|
*/
|
file?: string;
|
/**
|
* Optional flag to indicate we want results for just the current file
|
* or the entire project.
|
*/
|
currentFileOnly?: boolean;
|
projectFileName?: string;
|
}
|
/**
|
* Navto request message; value of command field is "navto".
|
* Return list of objects giving file locations and symbols that
|
* match the search term given in argument 'searchTerm'. The
|
* context for the search is given by the named file.
|
*/
|
interface NavtoRequest extends Request {
|
command: CommandTypes.Navto;
|
arguments: NavtoRequestArgs;
|
}
|
/**
|
* An item found in a navto response.
|
*/
|
interface NavtoItem extends FileSpan {
|
/**
|
* The symbol's name.
|
*/
|
name: string;
|
/**
|
* The symbol's kind (such as 'className' or 'parameterName').
|
*/
|
kind: ScriptElementKind;
|
/**
|
* exact, substring, or prefix.
|
*/
|
matchKind: string;
|
/**
|
* If this was a case sensitive or insensitive match.
|
*/
|
isCaseSensitive: boolean;
|
/**
|
* Optional modifiers for the kind (such as 'public').
|
*/
|
kindModifiers?: string;
|
/**
|
* Name of symbol's container symbol (if any); for example,
|
* the class name if symbol is a class member.
|
*/
|
containerName?: string;
|
/**
|
* Kind of symbol's container symbol (if any).
|
*/
|
containerKind?: ScriptElementKind;
|
}
|
/**
|
* Navto response message. Body is an array of navto items. Each
|
* item gives a symbol that matched the search term.
|
*/
|
interface NavtoResponse extends Response {
|
body?: NavtoItem[];
|
}
|
/**
|
* Arguments for change request message.
|
*/
|
interface ChangeRequestArgs extends FormatRequestArgs {
|
/**
|
* Optional string to insert at location (file, line, offset).
|
*/
|
insertString?: string;
|
}
|
/**
|
* Change request message; value of command field is "change".
|
* Update the server's view of the file named by argument 'file'.
|
* Server does not currently send a response to a change request.
|
*/
|
interface ChangeRequest extends FileLocationRequest {
|
command: CommandTypes.Change;
|
arguments: ChangeRequestArgs;
|
}
|
/**
|
* Response to "brace" request.
|
*/
|
interface BraceResponse extends Response {
|
body?: TextSpan[];
|
}
|
/**
|
* Brace matching request; value of command field is "brace".
|
* Return response giving the file locations of matching braces
|
* found in file at location line, offset.
|
*/
|
interface BraceRequest extends FileLocationRequest {
|
command: CommandTypes.Brace;
|
}
|
/**
|
* NavBar items request; value of command field is "navbar".
|
* Return response giving the list of navigation bar entries
|
* extracted from the requested file.
|
*/
|
interface NavBarRequest extends FileRequest {
|
command: CommandTypes.NavBar;
|
}
|
/**
|
* NavTree request; value of command field is "navtree".
|
* Return response giving the navigation tree of the requested file.
|
*/
|
interface NavTreeRequest extends FileRequest {
|
command: CommandTypes.NavTree;
|
}
|
interface NavigationBarItem {
|
/**
|
* The item's display text.
|
*/
|
text: string;
|
/**
|
* The symbol's kind (such as 'className' or 'parameterName').
|
*/
|
kind: ScriptElementKind;
|
/**
|
* Optional modifiers for the kind (such as 'public').
|
*/
|
kindModifiers?: string;
|
/**
|
* The definition locations of the item.
|
*/
|
spans: TextSpan[];
|
/**
|
* Optional children.
|
*/
|
childItems?: NavigationBarItem[];
|
/**
|
* Number of levels deep this item should appear.
|
*/
|
indent: number;
|
}
|
/** protocol.NavigationTree is identical to ts.NavigationTree, except using protocol.TextSpan instead of ts.TextSpan */
|
interface NavigationTree {
|
text: string;
|
kind: ScriptElementKind;
|
kindModifiers: string;
|
spans: TextSpan[];
|
nameSpan: TextSpan | undefined;
|
childItems?: NavigationTree[];
|
}
|
type TelemetryEventName = "telemetry";
|
interface TelemetryEvent extends Event {
|
event: TelemetryEventName;
|
body: TelemetryEventBody;
|
}
|
interface TelemetryEventBody {
|
telemetryEventName: string;
|
payload: any;
|
}
|
type TypesInstallerInitializationFailedEventName = "typesInstallerInitializationFailed";
|
interface TypesInstallerInitializationFailedEvent extends Event {
|
event: TypesInstallerInitializationFailedEventName;
|
body: TypesInstallerInitializationFailedEventBody;
|
}
|
interface TypesInstallerInitializationFailedEventBody {
|
message: string;
|
}
|
type TypingsInstalledTelemetryEventName = "typingsInstalled";
|
interface TypingsInstalledTelemetryEventBody extends TelemetryEventBody {
|
telemetryEventName: TypingsInstalledTelemetryEventName;
|
payload: TypingsInstalledTelemetryEventPayload;
|
}
|
interface TypingsInstalledTelemetryEventPayload {
|
/**
|
* Comma separated list of installed typing packages
|
*/
|
installedPackages: string;
|
/**
|
* true if install request succeeded, otherwise - false
|
*/
|
installSuccess: boolean;
|
/**
|
* version of typings installer
|
*/
|
typingsInstallerVersion: string;
|
}
|
type BeginInstallTypesEventName = "beginInstallTypes";
|
type EndInstallTypesEventName = "endInstallTypes";
|
interface BeginInstallTypesEvent extends Event {
|
event: BeginInstallTypesEventName;
|
body: BeginInstallTypesEventBody;
|
}
|
interface EndInstallTypesEvent extends Event {
|
event: EndInstallTypesEventName;
|
body: EndInstallTypesEventBody;
|
}
|
interface InstallTypesEventBody {
|
/**
|
* correlation id to match begin and end events
|
*/
|
eventId: number;
|
/**
|
* list of packages to install
|
*/
|
packages: readonly string[];
|
}
|
interface BeginInstallTypesEventBody extends InstallTypesEventBody {
|
}
|
interface EndInstallTypesEventBody extends InstallTypesEventBody {
|
/**
|
* true if installation succeeded, otherwise false
|
*/
|
success: boolean;
|
}
|
interface NavBarResponse extends Response {
|
body?: NavigationBarItem[];
|
}
|
interface NavTreeResponse extends Response {
|
body?: NavigationTree;
|
}
|
interface CallHierarchyItem {
|
name: string;
|
kind: ScriptElementKind;
|
kindModifiers?: string;
|
file: string;
|
span: TextSpan;
|
selectionSpan: TextSpan;
|
containerName?: string;
|
}
|
interface CallHierarchyIncomingCall {
|
from: CallHierarchyItem;
|
fromSpans: TextSpan[];
|
}
|
interface CallHierarchyOutgoingCall {
|
to: CallHierarchyItem;
|
fromSpans: TextSpan[];
|
}
|
interface PrepareCallHierarchyRequest extends FileLocationRequest {
|
command: CommandTypes.PrepareCallHierarchy;
|
}
|
interface PrepareCallHierarchyResponse extends Response {
|
readonly body: CallHierarchyItem | CallHierarchyItem[];
|
}
|
interface ProvideCallHierarchyIncomingCallsRequest extends FileLocationRequest {
|
command: CommandTypes.ProvideCallHierarchyIncomingCalls;
|
}
|
interface ProvideCallHierarchyIncomingCallsResponse extends Response {
|
readonly body: CallHierarchyIncomingCall[];
|
}
|
interface ProvideCallHierarchyOutgoingCallsRequest extends FileLocationRequest {
|
command: CommandTypes.ProvideCallHierarchyOutgoingCalls;
|
}
|
interface ProvideCallHierarchyOutgoingCallsResponse extends Response {
|
readonly body: CallHierarchyOutgoingCall[];
|
}
|
const enum IndentStyle {
|
None = "None",
|
Block = "Block",
|
Smart = "Smart"
|
}
|
enum SemicolonPreference {
|
Ignore = "ignore",
|
Insert = "insert",
|
Remove = "remove"
|
}
|
interface EditorSettings {
|
baseIndentSize?: number;
|
indentSize?: number;
|
tabSize?: number;
|
newLineCharacter?: string;
|
convertTabsToSpaces?: boolean;
|
indentStyle?: IndentStyle | ts.IndentStyle;
|
trimTrailingWhitespace?: boolean;
|
}
|
interface FormatCodeSettings extends EditorSettings {
|
insertSpaceAfterCommaDelimiter?: boolean;
|
insertSpaceAfterSemicolonInForStatements?: boolean;
|
insertSpaceBeforeAndAfterBinaryOperators?: boolean;
|
insertSpaceAfterConstructor?: boolean;
|
insertSpaceAfterKeywordsInControlFlowStatements?: boolean;
|
insertSpaceAfterFunctionKeywordForAnonymousFunctions?: boolean;
|
insertSpaceAfterOpeningAndBeforeClosingEmptyBraces?: boolean;
|
insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis?: boolean;
|
insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets?: boolean;
|
insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces?: boolean;
|
insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces?: boolean;
|
insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces?: boolean;
|
insertSpaceAfterTypeAssertion?: boolean;
|
insertSpaceBeforeFunctionParenthesis?: boolean;
|
placeOpenBraceOnNewLineForFunctions?: boolean;
|
placeOpenBraceOnNewLineForControlBlocks?: boolean;
|
insertSpaceBeforeTypeAnnotation?: boolean;
|
semicolons?: SemicolonPreference;
|
}
|
interface UserPreferences {
|
readonly disableSuggestions?: boolean;
|
readonly quotePreference?: "auto" | "double" | "single";
|
/**
|
* If enabled, TypeScript will search through all external modules' exports and add them to the completions list.
|
* This affects lone identifier completions but not completions on the right hand side of `obj.`.
|
*/
|
readonly includeCompletionsForModuleExports?: boolean;
|
/**
|
* Enables auto-import-style completions on partially-typed import statements. E.g., allows
|
* `import write|` to be completed to `import { writeFile } from "fs"`.
|
*/
|
readonly includeCompletionsForImportStatements?: boolean;
|
/**
|
* Allows completions to be formatted with snippet text, indicated by `CompletionItem["isSnippet"]`.
|
*/
|
readonly includeCompletionsWithSnippetText?: boolean;
|
/**
|
* If enabled, the completion list will include completions with invalid identifier names.
|
* For those entries, The `insertText` and `replacementSpan` properties will be set to change from `.x` property access to `["x"]`.
|
*/
|
readonly includeCompletionsWithInsertText?: boolean;
|
/**
|
* Unless this option is `false`, or `includeCompletionsWithInsertText` is not enabled,
|
* member completion lists triggered with `.` will include entries on potentially-null and potentially-undefined
|
* values, with insertion text to replace preceding `.` tokens with `?.`.
|
*/
|
readonly includeAutomaticOptionalChainCompletions?: boolean;
|
/**
|
* If enabled, completions for class members (e.g. methods and properties) will include
|
* a whole declaration for the member.
|
* E.g., `class A { f| }` could be completed to `class A { foo(): number {} }`, instead of
|
* `class A { foo }`.
|
*/
|
readonly includeCompletionsWithClassMemberSnippets?: boolean;
|
readonly allowIncompleteCompletions?: boolean;
|
readonly importModuleSpecifierPreference?: "shortest" | "project-relative" | "relative" | "non-relative";
|
/** Determines whether we import `foo/index.ts` as "foo", "foo/index", or "foo/index.js" */
|
readonly importModuleSpecifierEnding?: "auto" | "minimal" | "index" | "js";
|
readonly allowTextChangesInNewFiles?: boolean;
|
readonly lazyConfiguredProjectsFromExternalProject?: boolean;
|
readonly providePrefixAndSuffixTextForRename?: boolean;
|
readonly provideRefactorNotApplicableReason?: boolean;
|
readonly allowRenameOfImportPath?: boolean;
|
readonly includePackageJsonAutoImports?: "auto" | "on" | "off";
|
readonly jsxAttributeCompletionStyle?: "auto" | "braces" | "none";
|
readonly displayPartsForJSDoc?: boolean;
|
readonly generateReturnInDocTemplate?: boolean;
|
}
|
interface CompilerOptions {
|
allowJs?: boolean;
|
allowSyntheticDefaultImports?: boolean;
|
allowUnreachableCode?: boolean;
|
allowUnusedLabels?: boolean;
|
alwaysStrict?: boolean;
|
baseUrl?: string;
|
charset?: string;
|
checkJs?: boolean;
|
declaration?: boolean;
|
declarationDir?: string;
|
disableSizeLimit?: boolean;
|
downlevelIteration?: boolean;
|
emitBOM?: boolean;
|
emitDecoratorMetadata?: boolean;
|
experimentalDecorators?: boolean;
|
forceConsistentCasingInFileNames?: boolean;
|
importHelpers?: boolean;
|
inlineSourceMap?: boolean;
|
inlineSources?: boolean;
|
isolatedModules?: boolean;
|
jsx?: JsxEmit | ts.JsxEmit;
|
lib?: string[];
|
locale?: string;
|
mapRoot?: string;
|
maxNodeModuleJsDepth?: number;
|
module?: ModuleKind | ts.ModuleKind;
|
moduleResolution?: ModuleResolutionKind | ts.ModuleResolutionKind;
|
newLine?: NewLineKind | ts.NewLineKind;
|
noEmit?: boolean;
|
noEmitHelpers?: boolean;
|
noEmitOnError?: boolean;
|
noErrorTruncation?: boolean;
|
noFallthroughCasesInSwitch?: boolean;
|
noImplicitAny?: boolean;
|
noImplicitReturns?: boolean;
|
noImplicitThis?: boolean;
|
noUnusedLocals?: boolean;
|
noUnusedParameters?: boolean;
|
noImplicitUseStrict?: boolean;
|
noLib?: boolean;
|
noResolve?: boolean;
|
out?: string;
|
outDir?: string;
|
outFile?: string;
|
paths?: MapLike<string[]>;
|
plugins?: PluginImport[];
|
preserveConstEnums?: boolean;
|
preserveSymlinks?: boolean;
|
project?: string;
|
reactNamespace?: string;
|
removeComments?: boolean;
|
references?: ProjectReference[];
|
rootDir?: string;
|
rootDirs?: string[];
|
skipLibCheck?: boolean;
|
skipDefaultLibCheck?: boolean;
|
sourceMap?: boolean;
|
sourceRoot?: string;
|
strict?: boolean;
|
strictNullChecks?: boolean;
|
suppressExcessPropertyErrors?: boolean;
|
suppressImplicitAnyIndexErrors?: boolean;
|
useDefineForClassFields?: boolean;
|
target?: ScriptTarget | ts.ScriptTarget;
|
traceResolution?: boolean;
|
resolveJsonModule?: boolean;
|
types?: string[];
|
/** Paths used to used to compute primary types search locations */
|
typeRoots?: string[];
|
[option: string]: CompilerOptionsValue | undefined;
|
}
|
const enum JsxEmit {
|
None = "None",
|
Preserve = "Preserve",
|
ReactNative = "ReactNative",
|
React = "React"
|
}
|
const enum ModuleKind {
|
None = "None",
|
CommonJS = "CommonJS",
|
AMD = "AMD",
|
UMD = "UMD",
|
System = "System",
|
ES6 = "ES6",
|
ES2015 = "ES2015",
|
ESNext = "ESNext"
|
}
|
const enum ModuleResolutionKind {
|
Classic = "Classic",
|
Node = "Node"
|
}
|
const enum NewLineKind {
|
Crlf = "Crlf",
|
Lf = "Lf"
|
}
|
const enum ScriptTarget {
|
ES3 = "ES3",
|
ES5 = "ES5",
|
ES6 = "ES6",
|
ES2015 = "ES2015",
|
ES2016 = "ES2016",
|
ES2017 = "ES2017",
|
ES2018 = "ES2018",
|
ES2019 = "ES2019",
|
ES2020 = "ES2020",
|
ES2021 = "ES2021",
|
ES2022 = "ES2022",
|
ESNext = "ESNext"
|
}
|
const enum ClassificationType {
|
comment = 1,
|
identifier = 2,
|
keyword = 3,
|
numericLiteral = 4,
|
operator = 5,
|
stringLiteral = 6,
|
regularExpressionLiteral = 7,
|
whiteSpace = 8,
|
text = 9,
|
punctuation = 10,
|
className = 11,
|
enumName = 12,
|
interfaceName = 13,
|
moduleName = 14,
|
typeParameterName = 15,
|
typeAliasName = 16,
|
parameterName = 17,
|
docCommentTagName = 18,
|
jsxOpenTagName = 19,
|
jsxCloseTagName = 20,
|
jsxSelfClosingTagName = 21,
|
jsxAttribute = 22,
|
jsxText = 23,
|
jsxAttributeStringLiteralValue = 24,
|
bigintLiteral = 25
|
}
|
}
|
declare namespace ts.server.protocol {
|
|
interface TextInsertion {
|
newText: string;
|
/** The position in newText the caret should point to after the insertion. */
|
caretOffset: number;
|
}
|
|
interface TodoCommentDescriptor {
|
text: string;
|
priority: number;
|
}
|
|
interface TodoComment {
|
descriptor: TodoCommentDescriptor;
|
message: string;
|
position: number;
|
}
|
|
enum OutliningSpanKind {
|
/** Single or multi-line comments */
|
Comment = "comment",
|
/** Sections marked by '// #region' and '// #endregion' comments */
|
Region = "region",
|
/** Declarations and expressions */
|
Code = "code",
|
/** Contiguous blocks of import declarations */
|
Imports = "imports"
|
}
|
|
enum HighlightSpanKind {
|
none = "none",
|
definition = "definition",
|
reference = "reference",
|
writtenReference = "writtenReference"
|
}
|
|
enum ScriptElementKind {
|
unknown = "",
|
warning = "warning",
|
/** predefined type (void) or keyword (class) */
|
keyword = "keyword",
|
/** top level script node */
|
scriptElement = "script",
|
/** module foo {} */
|
moduleElement = "module",
|
/** class X {} */
|
classElement = "class",
|
/** var x = class X {} */
|
localClassElement = "local class",
|
/** interface Y {} */
|
interfaceElement = "interface",
|
/** type T = ... */
|
typeElement = "type",
|
/** enum E */
|
enumElement = "enum",
|
enumMemberElement = "enum member",
|
/**
|
* Inside module and script only
|
* const v = ..
|
*/
|
variableElement = "var",
|
/** Inside function */
|
localVariableElement = "local var",
|
/**
|
* Inside module and script only
|
* function f() { }
|
*/
|
functionElement = "function",
|
/** Inside function */
|
localFunctionElement = "local function",
|
/** class X { [public|private]* foo() {} } */
|
memberFunctionElement = "method",
|
/** class X { [public|private]* [get|set] foo:number; } */
|
memberGetAccessorElement = "getter",
|
memberSetAccessorElement = "setter",
|
/**
|
* class X { [public|private]* foo:number; }
|
* interface Y { foo:number; }
|
*/
|
memberVariableElement = "property",
|
/**
|
* class X { constructor() { } }
|
* class X { static { } }
|
*/
|
constructorImplementationElement = "constructor",
|
/** interface Y { ():number; } */
|
callSignatureElement = "call",
|
/** interface Y { []:number; } */
|
indexSignatureElement = "index",
|
/** interface Y { new():Y; } */
|
constructSignatureElement = "construct",
|
/** function foo(*Y*: string) */
|
parameterElement = "parameter",
|
typeParameterElement = "type parameter",
|
primitiveType = "primitive type",
|
label = "label",
|
alias = "alias",
|
constElement = "const",
|
letElement = "let",
|
directory = "directory",
|
externalModuleName = "external module name",
|
/**
|
* <JsxTagName attribute1 attribute2={0} />
|
* @deprecated
|
*/
|
jsxAttribute = "JSX attribute",
|
/** String literal */
|
string = "string",
|
/** Jsdoc @link: in `{@link C link text}`, the before and after text "{@link " and "}" */
|
link = "link",
|
/** Jsdoc @link: in `{@link C link text}`, the entity name "C" */
|
linkName = "link name",
|
/** Jsdoc @link: in `{@link C link text}`, the link text "link text" */
|
linkText = "link text"
|
}
|
|
export interface TypeAcquisition {
|
/**
|
* @deprecated typingOptions.enableAutoDiscovery
|
* Use typeAcquisition.enable instead.
|
*/
|
enableAutoDiscovery?: boolean;
|
enable?: boolean;
|
include?: string[];
|
exclude?: string[];
|
disableFilenameBasedTypeAcquisition?: boolean;
|
[option: string]: CompilerOptionsValue | undefined;
|
}
|
|
export type CompilerOptionsValue = string | number | boolean | (string | number)[] | string[] | MapLike<string[]> | PluginImport[] | ProjectReference[] | null | undefined;
|
|
export interface FileExtensionInfo {
|
extension: string;
|
isMixedContent: boolean;
|
scriptKind?: ScriptKind;
|
}
|
|
/**
|
* Type of objects whose values are all of the same type.
|
* The `in` and `for-in` operators can *not* be safely used,
|
* since `Object.prototype` may be modified by outside code.
|
*/
|
interface MapLike<T> {
|
[index: string]: T;
|
}
|
|
export interface PluginImport {
|
name: string;
|
}
|
|
export interface ProjectReference {
|
/** A normalized path on disk */
|
path: string;
|
/** The path as the user originally wrote it */
|
originalPath?: string;
|
/** True if the output of this reference should be prepended to the output of this project. Only valid for --outFile compilations */
|
prepend?: boolean;
|
/** True if it is intended that this reference form a circularity */
|
circular?: boolean;
|
}
|
}
|
declare namespace ts {
|
// these types are empty stubs for types from services and should not be used directly
|
export type EndOfLineState = never;
|
export type ScriptKind = never;
|
export type WatchFileKind = never;
|
export type WatchDirectoryKind = never;
|
export type PollingWatchKind = never;
|
export type IndentStyle = never;
|
export type JsxEmit = never;
|
export type ModuleKind = never;
|
export type ModuleResolutionKind = never;
|
export type NewLineKind = never;
|
export type ScriptTarget = never;
|
}
|
import protocol = ts.server.protocol;
|
export = protocol;
|
export as namespace protocol;
|
