/**

* Declaration module describing the TypeScript Server protocol

*/

declare namespace ts.server.protocol {

const enum CommandTypes {

Brace = "brace",

BraceCompletion = "braceCompletion",

GetSpanOfEnclosingComment = "getSpanOfEnclosingComment",

Change = "change",

Close = "close",

Completions = "completions",

CompletionDetails = "completionEntryDetails",

CompileOnSaveAffectedFileList = "compileOnSaveAffectedFileList",

CompileOnSaveEmitFile = "compileOnSaveEmitFile",

Configure = "configure",

Definition = "definition",

DefinitionAndBoundSpan = "definitionAndBoundSpan",

Implementation = "implementation",

Exit = "exit",

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",

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"

}

/**

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

}

/**

* 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?: {};

}

/**

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

/**

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

}

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;

}

interface OrganizeImportsResponse extends Response {

edits: ReadonlyArray<FileCodeEdits>;

}

interface GetEditsForFileRenameRequest extends Request {

command: CommandTypes.GetEditsForFileRename;

arguments: GetEditsForFileRenameRequestArgs;

}

interface GetEditsForFileRenameRequestArgs extends FileRequestArgs {

readonly oldFilePath: string;

readonly newFilePath: string;

}

interface GetEditsForFileRenameResponse extends Response {

edits: ReadonlyArray<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?: ReadonlyArray<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[];

}

/**

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

definitions: ReadonlyArray<FileSpan>;

textSpan: TextSpan;

}

/**

* Definition response message. Gives text range for definition.

*/

interface DefinitionResponse extends Response {

body?: FileSpan[];

}

interface DefinitionInfoAndBoundSpanReponse extends Response {

body?: DefinitionInfoAndBoundSpan;

}

/**

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

}

/**

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

/**

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

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

/**

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

/**

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

preferences?: UserPreferences;

/**

* The host's additional supported .js file extensions

*/

extraFileExtensions?: FileExtensionInfo[];

}

/**

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

/**

* 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