/**

* Declaration module describing the TypeScript Server protocol

*/

declare namespace ts.server.protocol {

namespace CommandTypes {

type Brace = "brace";

type BraceCompletion = "braceCompletion";

type Change = "change";

type Close = "close";

type Completions = "completions";

type CompletionDetails = "completionEntryDetails";

type CompileOnSaveAffectedFileList = "compileOnSaveAffectedFileList";

type CompileOnSaveEmitFile = "compileOnSaveEmitFile";

type Configure = "configure";

type Definition = "definition";

type Implementation = "implementation";

type Exit = "exit";

type Format = "format";

type Formatonkey = "formatonkey";

type Geterr = "geterr";

type GeterrForProject = "geterrForProject";

type SemanticDiagnosticsSync = "semanticDiagnosticsSync";

type SyntacticDiagnosticsSync = "syntacticDiagnosticsSync";

type NavBar = "navbar";

type Navto = "navto";

type NavTree = "navtree";

type NavTreeFull = "navtree-full";

type Occurrences = "occurrences";

type DocumentHighlights = "documentHighlights";

type Open = "open";

type Quickinfo = "quickinfo";

type References = "references";

type Reload = "reload";

type Rename = "rename";

type Saveto = "saveto";

type SignatureHelp = "signatureHelp";

type TypeDefinition = "typeDefinition";

type ProjectInfo = "projectInfo";

type ReloadProjects = "reloadProjects";

type Unknown = "unknown";

type OpenExternalProject = "openExternalProject";

type OpenExternalProjects = "openExternalProjects";

type CloseExternalProject = "closeExternalProject";

type TodoComments = "todoComments";

type Indentation = "indentation";

type DocCommentTemplate = "docCommentTemplate";

type CompilerOptionsForInferredProjects = "compilerOptionsForInferredProjects";

type GetCodeFixes = "getCodeFixes";

type GetSupportedCodeFixes = "getSupportedCodeFixes";

}

/**

* 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 {

/**

* 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 {

/**

* Name of event

*/

event: string;

/**

* Event-specific information

*/

body?: any;

}

/**

* Response by server to client request message.

*/

interface Response extends Message {

/**

* Sequence number of the request message.

*/

request_seq: number;

/**

* Outcome of the request.

*/

success: boolean;

/**

* The command requested.

*/

command: string;

/**

* Contains error message if success === false.

*/

message?: string;

/**

* Contains message body if success === true.

*/

body?: any;

}

/**

* Arguments for FileRequest messages.

*/

interface FileRequestArgs {

/**

* The file for the request (absolute pathname required).

*/

file: string;

projectFileName?: string;

}

/**

* 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 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;

}

/**

* 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;

}

/**

* Request for the available codefixes at a specific position.

*/

interface CodeFixRequest extends Request {

command: CommandTypes.GetCodeFixes;

arguments: CodeFixRequestArgs;

}

/**

* Instances of this interface specify errorcodes on a specific location in a sourcefile.

*/

interface CodeFixRequestArgs 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;

/**

* Errorcodes we want to get the fixes for.

*/

errorCodes?: number[];

}

/**

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

}

/**

* Arguments for EncodedSemanticClassificationsRequest request.

*/

interface EncodedSemanticClassificationsRequestArgs extends FileRequestArgs {

/**

* Start position of the span.

*/

start: number;

/**

* Length of the span.

*/

length: 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;

}

/**

* 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 character 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;

}

/**

* Definition response message. Gives text range for definition.

*/

interface DefinitionResponse extends Response {

body?: FileSpan[];

}

/**

* Definition response message. Gives text range for definition.

*/

interface TypeDefinitionResponse extends Response {

body?: FileSpan[];

}

/**

* Implementation response message. Gives text range for implementations.

*/

interface ImplementationResponse extends Response {

body?: FileSpan[];

}

/**

* 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;

}

/**

* 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;

}

interface OccurrencesResponseItem extends FileSpan {

/**

* True if the occurrence is a write location, false otherwise.

*/

isWriteAccess: boolean;

}

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.

* Kind is taken from HighlightSpanKind type.

*/

interface HighlightSpan extends TextSpan {

kind: string;

}

/**

* 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 FileSpan {

/** 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: 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;

}

/**

* 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.

*/

interface RenameInfo {

/**

* True if item can be renamed.

*/

canRename: boolean;

/**

* Error message if item can not be renamed.

*/

localizedErrorMessage?: 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: string;

/**

* Optional modifiers for the kind (such as 'public').

*/

kindModifiers: 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: TextSpan[];

}

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: 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 explicity.

* 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;

/**

* Represents a set of changes that happen in project

*/

interface ProjectChanges {

/**

* List of added files

*/

added: string[];

/**

* List of removed files

*/

removed: string[];

/**

* List of updated files

*/

updated: string[];

}

/**

* 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;

/**

* The host's additional supported .js file extensions

*/

extraFileExtensions?: JsFileExtensionInfo[];

}

/**

* 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 {

}

/**

* 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;

}

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 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: ExternalProjectCompilerOptions;

}

/**

* 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;

}

/**

* 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;

}

/**

* Body of QuickInfoResponse.

*/

interface QuickInfoResponseBody {

/**

* The symbol's kind (such as 'className' or 'parameterName' or plain 'text').

*/

kind: string;

/**

* 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.

*/

documentation: string;

}

/**

* 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