| /** |
| * 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" |
| } |
| /** |
| * 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; |
| } |
| /** |
| * 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: ReadonlyArray<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: 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; |
| } |
| 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 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; |
| } |
| 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 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: ReadonlyArray<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 TextSpan { |
| 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: 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 { |
| } |
| 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; |
| } |
| /** |
| * 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: ReadonlyArray<FileCodeEdits>; |
| commands?: ReadonlyArray<{}>; |
| } |
| 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; |
| } |
| /** |
| * 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: ReadonlyArray<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 extends FileRequestArgs { |
| /** |
| * 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; |
| /** |
| * 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 FileRequest { |
| 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: ReadonlyArray<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; |
| } |
| const enum IndentStyle { |
| None = "None", |
| Block = "Block", |
| Smart = "Smart" |
| } |
| interface EditorSettings { |
| baseIndentSize?: number; |
| indentSize?: number; |
| tabSize?: number; |
| newLineCharacter?: string; |
| convertTabsToSpaces?: boolean; |
| indentStyle?: IndentStyle | ts.IndentStyle; |
| } |
| 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; |
| } |
| 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; |
| readonly importModuleSpecifierPreference?: "relative" | "non-relative"; |
| 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; |
| 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" |
| } |
| |
| interface TypeAcquisition { |
| enableAutoDiscovery?: boolean; |
| enable?: boolean; |
| include?: string[]; |
| exclude?: string[]; |
| [option: string]: string[] | boolean | undefined; |
| } |
| |
| interface FileExtensionInfo { |
| extension: string; |
| isMixedContent: boolean; |
| scriptKind?: ScriptKind; |
| } |
| |
| 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; |
| } |
| |
| interface PluginImport { |
| name: string; |
| } |
| |
| 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; |
| } |
| |
| type CompilerOptionsValue = string | number | boolean | (string | number)[] | string[] | MapLike<string[]> | PluginImport[] | ProjectReference[] | null | undefined; |
| } |
| declare namespace ts { |
| // these types are empty stubs for types from services and should not be used directly |
| export type ScriptKind = 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; |