--- /dev/null
+/**
+ * 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",
+ 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",
+ PrepareCallHierarchy = "prepareCallHierarchy",
+ ProvideCallHierarchyIncomingCalls = "provideCallHierarchyIncomingCalls",
+ ProvideCallHierarchyOutgoingCalls = "provideCallHierarchyOutgoingCalls"
+ }
+ /**
+ * 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;
+ }
+ /**
+ * 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?: {};
+ 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;
+ /**
+ * 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 {
+ 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[];
+ }
+ /**
+ * 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 TextSpanWithContext extends TextSpan {
+ contextStart?: Location;
+ contextEnd?: Location;
+ }
+ interface FileSpanWithContext extends FileSpan, TextSpanWithContext {
+ }
+ interface DefinitionInfoAndBoundSpan {
+ definitions: readonly FileSpanWithContext[];
+ textSpan: TextSpan;
+ }
+ /**
+ * Definition response message. Gives text range for definition.
+ */
+ interface DefinitionResponse extends Response {
+ body?: FileSpanWithContext[];
+ }
+ 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;
+ }
+ /**
+ * 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",
+ UseFsEvents = "UseFsEvents",
+ UseFsEventsOnParentDirectory = "UseFsEventsOnParentDirectory"
+ }
+ const enum WatchDirectoryKind {
+ UseFsEvents = "UseFsEvents",
+ FixedPollingInterval = "FixedPollingInterval",
+ DynamicPriorityPolling = "DynamicPriorityPolling"
+ }
+ const enum PollingWatchKind {
+ FixedInterval = "FixedInterval",
+ PriorityInterval = "PriorityInterval",
+ DynamicPriority = "DynamicPriority"
+ }
+ interface WatchOptions {
+ watchFile?: WatchFileKind | ts.WatchFileKind;
+ watchDirectory?: WatchDirectoryKind | ts.WatchDirectoryKind;
+ fallbackPolling?: PollingWatchKind | ts.PollingWatchKind;
+ synchronousWatchDirectory?: boolean;
+ [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;
+ }
+ /**
+ * 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[];
+ }
+ /**
+ * 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;
+ /**
+ * 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;
+ }
+ /**
+ * 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.
+ */
+ documentation: string;
+ /**
+ * 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 = "." | '"' | "'" | "`" | "/" | "@" | "<" | "#";
+ /**
+ * 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;
+ /**
+ * @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;
+ }
+ /**
+ * 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;
+ }
+ /**
+ * 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;
+ /**
+ * 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;
+ /**
+ * 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;
+ }
+ /**
+ * 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[];
+ /**
+ * Human-readable description of the `source` from the CompletionEntry.
+ */
+ source?: 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;
+ 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;
+ }
+ /**
+ * 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?: {};
+ /**
+ * 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;
+ file: string;
+ span: TextSpan;
+ selectionSpan: TextSpan;
+ }
+ 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;
+ 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;
+ /**
+ * 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;
+ readonly importModuleSpecifierPreference?: "auto" | "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 allowRenameOfImportPath?: 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",
+ ESNext = "ESNext"
+ }
+}
+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() { } } */
+ 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} />
+ */
+ jsxAttribute = "JSX attribute",
+ /** String literal */
+ string = "string"
+ }
+
+ export interface TypeAcquisition {
+ /**
+ * @deprecated typingOptions.enableAutoDiscovery
+ * Use typeAcquisition.enable instead.
+ */
+ enableAutoDiscovery?: boolean;
+ enable?: boolean;
+ include?: string[];
+ exclude?: string[];
+ [option: string]: string[] | boolean | undefined;
+ }
+
+ export interface FileExtensionInfo {
+ extension: string;
+ isMixedContent: boolean;
+ scriptKind?: ScriptKind;
+ }
+
+ export type CompilerOptionsValue = string | number | boolean | (string | number)[] | string[] | MapLike<string[]> | PluginImport[] | ProjectReference[] | null | undefined;
+
+ interface JSDocTagInfo {
+ name: string;
+ text?: string;
+ }
+
+ /**
+ * 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 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;
\ No newline at end of file
projects / dotfiles / .git / blobdiff