tsrc 2.1.5.0

data/lib/tsrc/support/typescript/lib/protocol.d.ts

@@ -0,0 +1,1900 @@
+/**
+  * Declaration module describing the TypeScript Server protocol
+  */
+declare namespace ts.server.protocol {
+    namespace CommandTypes {
+        type Brace = "brace";
+        type BraceCompletion = "braceCompletion";
+        type Change = "change";
+        type Close = "close";
+        type Completions = "completions";
+        type CompletionDetails = "completionEntryDetails";
+        type CompileOnSaveAffectedFileList = "compileOnSaveAffectedFileList";
+        type CompileOnSaveEmitFile = "compileOnSaveEmitFile";
+        type Configure = "configure";
+        type Definition = "definition";
+        type Implementation = "implementation";
+        type Exit = "exit";
+        type Format = "format";
+        type Formatonkey = "formatonkey";
+        type Geterr = "geterr";
+        type GeterrForProject = "geterrForProject";
+        type SemanticDiagnosticsSync = "semanticDiagnosticsSync";
+        type SyntacticDiagnosticsSync = "syntacticDiagnosticsSync";
+        type NavBar = "navbar";
+        type Navto = "navto";
+        type NavTree = "navtree";
+        type NavTreeFull = "navtree-full";
+        type Occurrences = "occurrences";
+        type DocumentHighlights = "documentHighlights";
+        type Open = "open";
+        type Quickinfo = "quickinfo";
+        type References = "references";
+        type Reload = "reload";
+        type Rename = "rename";
+        type Saveto = "saveto";
+        type SignatureHelp = "signatureHelp";
+        type TypeDefinition = "typeDefinition";
+        type ProjectInfo = "projectInfo";
+        type ReloadProjects = "reloadProjects";
+        type Unknown = "unknown";
+        type OpenExternalProject = "openExternalProject";
+        type OpenExternalProjects = "openExternalProjects";
+        type CloseExternalProject = "closeExternalProject";
+        type TodoComments = "todoComments";
+        type Indentation = "indentation";
+        type DocCommentTemplate = "docCommentTemplate";
+        type CompilerOptionsForInferredProjects = "compilerOptionsForInferredProjects";
+        type GetCodeFixes = "getCodeFixes";
+        type GetSupportedCodeFixes = "getSupportedCodeFixes";
+    }
+    /**
+      * A TypeScript Server message
+      */
+    interface Message {
+        /**
+          * Sequence number of the message
+          */
+        seq: number;
+        /**
+          * One of "request", "response", or "event"
+          */
+        type: "request" | "response" | "event";
+    }
+    /**
+      * Client-initiated request message
+      */
+    interface Request extends Message {
+        /**
+          * The command to execute
+          */
+        command: string;
+        /**
+          * Object containing arguments for the command
+          */
+        arguments?: any;
+    }
+    /**
+      * Request to reload the project structure for all the opened files
+      */
+    interface ReloadProjectsRequest extends Message {
+        command: CommandTypes.ReloadProjects;
+    }
+    /**
+      * Server-initiated event message
+      */
+    interface Event extends Message {
+        /**
+          * Name of event
+          */
+        event: string;
+        /**
+          * Event-specific information
+          */
+        body?: any;
+    }
+    /**
+      * Response by server to client request message.
+      */
+    interface Response extends Message {
+        /**
+          * Sequence number of the request message.
+          */
+        request_seq: number;
+        /**
+          * Outcome of the request.
+          */
+        success: boolean;
+        /**
+          * The command requested.
+          */
+        command: string;
+        /**
+          * Contains error message if success === false.
+          */
+        message?: string;
+        /**
+          * Contains message body if success === true.
+          */
+        body?: any;
+    }
+    /**
+      * Arguments for FileRequest messages.
+      */
+    interface FileRequestArgs {
+        /**
+          * The file for the request (absolute pathname required).
+          */
+        file: string;
+        projectFileName?: string;
+    }
+    /**
+     * Requests a JS Doc comment template for a given position
+     */
+    interface DocCommentTemplateRequest extends FileLocationRequest {
+        command: CommandTypes.DocCommentTemplate;
+    }
+    /**
+     * Response to DocCommentTemplateRequest
+     */
+    interface DocCommandTemplateResponse extends Response {
+        body?: TextInsertion;
+    }
+    /**
+     * A request to get TODO comments from the file
+     */
+    interface TodoCommentRequest extends FileRequest {
+        command: CommandTypes.TodoComments;
+        arguments: TodoCommentRequestArgs;
+    }
+    /**
+     * Arguments for TodoCommentRequest request.
+     */
+    interface TodoCommentRequestArgs extends FileRequestArgs {
+        /**
+         * Array of target TodoCommentDescriptors that describes TODO comments to be found
+         */
+        descriptors: TodoCommentDescriptor[];
+    }
+    /**
+     * Response for TodoCommentRequest request.
+     */
+    interface TodoCommentsResponse extends Response {
+        body?: TodoComment[];
+    }
+    /**
+     * A request to get indentation for a location in file
+     */
+    interface IndentationRequest extends FileLocationRequest {
+        command: CommandTypes.Indentation;
+        arguments: IndentationRequestArgs;
+    }
+    /**
+     * Response for IndentationRequest request.
+     */
+    interface IndentationResponse extends Response {
+        body?: IndentationResult;
+    }
+    /**
+     * Indentation result representing where indentation should be placed
+     */
+    interface IndentationResult {
+        /**
+         * The base position in the document that the indent should be relative to
+         */
+        position: number;
+        /**
+         * The number of columns the indent should be at relative to the position's column.
+         */
+        indentation: number;
+    }
+    /**
+     * Arguments for IndentationRequest request.
+     */
+    interface IndentationRequestArgs extends FileLocationRequestArgs {
+        /**
+         * An optional set of settings to be used when computing indentation.
+         * If argument is omitted - then it will use settings for file that were previously set via 'configure' request or global settings.
+         */
+        options?: EditorSettings;
+    }
+    /**
+      * Arguments for ProjectInfoRequest request.
+      */
+    interface ProjectInfoRequestArgs extends FileRequestArgs {
+        /**
+          * Indicate if the file name list of the project is needed
+          */
+        needFileNameList: boolean;
+    }
+    /**
+      * A request to get the project information of the current file.
+      */
+    interface ProjectInfoRequest extends Request {
+        command: CommandTypes.ProjectInfo;
+        arguments: ProjectInfoRequestArgs;
+    }
+    /**
+     * A request to retrieve compiler options diagnostics for a project
+     */
+    interface CompilerOptionsDiagnosticsRequest extends Request {
+        arguments: CompilerOptionsDiagnosticsRequestArgs;
+    }
+    /**
+     * Arguments for CompilerOptionsDiagnosticsRequest request.
+     */
+    interface CompilerOptionsDiagnosticsRequestArgs {
+        /**
+         * Name of the project to retrieve compiler options diagnostics.
+         */
+        projectFileName: string;
+    }
+    /**
+      * Response message body for "projectInfo" request
+      */
+    interface ProjectInfo {
+        /**
+          * For configured project, this is the normalized path of the 'tsconfig.json' file
+          * For inferred project, this is undefined
+          */
+        configFileName: string;
+        /**
+          * The list of normalized file name in the project, including 'lib.d.ts'
+          */
+        fileNames?: string[];
+        /**
+          * Indicates if the project has a active language service instance
+          */
+        languageServiceDisabled?: boolean;
+    }
+    /**
+     * Represents diagnostic info that includes location of diagnostic in two forms
+     * - start position and length of the error span
+     * - startLocation and endLocation - a pair of Location objects that store start/end line and offset of the error span.
+     */
+    interface DiagnosticWithLinePosition {
+        message: string;
+        start: number;
+        length: number;
+        startLocation: Location;
+        endLocation: Location;
+        category: string;
+        code: number;
+    }
+    /**
+      * Response message for "projectInfo" request
+      */
+    interface ProjectInfoResponse extends Response {
+        body?: ProjectInfo;
+    }
+    /**
+      * Request whose sole parameter is a file name.
+      */
+    interface FileRequest extends Request {
+        arguments: FileRequestArgs;
+    }
+    /**
+      * Instances of this interface specify a location in a source file:
+      * (file, line, character offset), where line and character offset are 1-based.
+      */
+    interface FileLocationRequestArgs extends FileRequestArgs {
+        /**
+          * The line number for the request (1-based).
+          */
+        line: number;
+        /**
+          * The character offset (on the line) for the request (1-based).
+          */
+        offset: number;
+    }
+    /**
+      * Request for the available codefixes at a specific position.
+      */
+    interface CodeFixRequest extends Request {
+        command: CommandTypes.GetCodeFixes;
+        arguments: CodeFixRequestArgs;
+    }
+    /**
+      * Instances of this interface specify errorcodes on a specific location in a sourcefile.
+      */
+    interface CodeFixRequestArgs extends FileRequestArgs {
+        /**
+          * The line number for the request (1-based).
+          */
+        startLine: number;
+        /**
+          * The character offset (on the line) for the request (1-based).
+          */
+        startOffset: number;
+        /**
+          * The line number for the request (1-based).
+          */
+        endLine: number;
+        /**
+          * The character offset (on the line) for the request (1-based).
+          */
+        endOffset: number;
+        /**
+          * Errorcodes we want to get the fixes for.
+          */
+        errorCodes?: number[];
+    }
+    /**
+     * Response for GetCodeFixes request.
+     */
+    interface GetCodeFixesResponse extends Response {
+        body?: CodeAction[];
+    }
+    /**
+      * A request whose arguments specify a file location (file, line, col).
+      */
+    interface FileLocationRequest extends FileRequest {
+        arguments: FileLocationRequestArgs;
+    }
+    /**
+     * A request to get codes of supported code fixes.
+     */
+    interface GetSupportedCodeFixesRequest extends Request {
+        command: CommandTypes.GetSupportedCodeFixes;
+    }
+    /**
+     * A response for GetSupportedCodeFixesRequest request.
+     */
+    interface GetSupportedCodeFixesResponse extends Response {
+        /**
+         * List of error codes supported by the server.
+         */
+        body?: string[];
+    }
+    /**
+     * Arguments for EncodedSemanticClassificationsRequest request.
+     */
+    interface EncodedSemanticClassificationsRequestArgs extends FileRequestArgs {
+        /**
+         * Start position of the span.
+         */
+        start: number;
+        /**
+         * Length of the span.
+         */
+        length: number;
+    }
+    /**
+      * Arguments in document highlight request; include: filesToSearch, file,
+      * line, offset.
+      */
+    interface DocumentHighlightsRequestArgs extends FileLocationRequestArgs {
+        /**
+         * List of files to search for document highlights.
+         */
+        filesToSearch: string[];
+    }
+    /**
+      * Go to definition request; value of command field is
+      * "definition". Return response giving the file locations that
+      * define the symbol found in file at location line, col.
+      */
+    interface DefinitionRequest extends FileLocationRequest {
+        command: CommandTypes.Definition;
+    }
+    /**
+      * Go to type request; value of command field is
+      * "typeDefinition". Return response giving the file locations that
+      * define the type for the symbol found in file at location line, col.
+      */
+    interface TypeDefinitionRequest extends FileLocationRequest {
+        command: CommandTypes.TypeDefinition;
+    }
+    /**
+      * Go to implementation request; value of command field is
+      * "implementation". Return response giving the file locations that
+      * implement the symbol found in file at location line, col.
+      */
+    interface ImplementationRequest extends FileLocationRequest {
+        command: CommandTypes.Implementation;
+    }
+    /**
+      * Location in source code expressed as (one-based) line and character offset.
+      */
+    interface Location {
+        line: number;
+        offset: number;
+    }
+    /**
+      * Object found in response messages defining a span of text in source code.
+      */
+    interface TextSpan {
+        /**
+          * First character of the definition.
+          */
+        start: Location;
+        /**
+          * One character past last character of the definition.
+          */
+        end: Location;
+    }
+    /**
+      * Object found in response messages defining a span of text in a specific source file.
+      */
+    interface FileSpan extends TextSpan {
+        /**
+          * File containing text span.
+          */
+        file: string;
+    }
+    /**
+      * Definition response message.  Gives text range for definition.
+      */
+    interface DefinitionResponse extends Response {
+        body?: FileSpan[];
+    }
+    /**
+      * Definition response message.  Gives text range for definition.
+      */
+    interface TypeDefinitionResponse extends Response {
+        body?: FileSpan[];
+    }
+    /**
+      * Implementation response message.  Gives text range for implementations.
+      */
+    interface ImplementationResponse extends Response {
+        body?: FileSpan[];
+    }
+    /**
+     * Request to get brace completion for a location in the file.
+     */
+    interface BraceCompletionRequest extends FileLocationRequest {
+        command: CommandTypes.BraceCompletion;
+        arguments: BraceCompletionRequestArgs;
+    }
+    /**
+     * Argument for BraceCompletionRequest request.
+     */
+    interface BraceCompletionRequestArgs extends FileLocationRequestArgs {
+        /**
+         * Kind of opening brace
+         */
+        openingBrace: string;
+    }
+    /**
+      * Get occurrences request; value of command field is
+      * "occurrences". Return response giving spans that are relevant
+      * in the file at a given line and column.
+      */
+    interface OccurrencesRequest extends FileLocationRequest {
+        command: CommandTypes.Occurrences;
+    }
+    interface OccurrencesResponseItem extends FileSpan {
+        /**
+          * True if the occurrence is a write location, false otherwise.
+          */
+        isWriteAccess: boolean;
+    }
+    interface OccurrencesResponse extends Response {
+        body?: OccurrencesResponseItem[];
+    }
+    /**
+      * Get document highlights request; value of command field is
+      * "documentHighlights". Return response giving spans that are relevant
+      * in the file at a given line and column.
+      */
+    interface DocumentHighlightsRequest extends FileLocationRequest {
+        command: CommandTypes.DocumentHighlights;
+        arguments: DocumentHighlightsRequestArgs;
+    }
+    /**
+     * Span augmented with extra information that denotes the kind of the highlighting to be used for span.
+     * Kind is taken from HighlightSpanKind type.
+     */
+    interface HighlightSpan extends TextSpan {
+        kind: string;
+    }
+    /**
+     * Represents a set of highligh spans for a give name
+     */
+    interface DocumentHighlightsItem {
+        /**
+          * File containing highlight spans.
+          */
+        file: string;
+        /**
+          * Spans to highlight in file.
+          */
+        highlightSpans: HighlightSpan[];
+    }
+    /**
+     * Response for a DocumentHighlightsRequest request.
+     */
+    interface DocumentHighlightsResponse extends Response {
+        body?: DocumentHighlightsItem[];
+    }
+    /**
+      * Find references request; value of command field is
+      * "references". Return response giving the file locations that
+      * reference the symbol found in file at location line, col.
+      */
+    interface ReferencesRequest extends FileLocationRequest {
+        command: CommandTypes.References;
+    }
+    interface ReferencesResponseItem extends FileSpan {
+        /** Text of line containing the reference.  Including this
+          *  with the response avoids latency of editor loading files
+          * to show text of reference line (the server already has
+          * loaded the referencing files).
+          */
+        lineText: string;
+        /**
+          * True if reference is a write location, false otherwise.
+          */
+        isWriteAccess: boolean;
+        /**
+         * True if reference is a definition, false otherwise.
+         */
+        isDefinition: boolean;
+    }
+    /**
+      * The body of a "references" response message.
+      */
+    interface ReferencesResponseBody {
+        /**
+          * The file locations referencing the symbol.
+          */
+        refs: ReferencesResponseItem[];
+        /**
+          * The name of the symbol.
+          */
+        symbolName: string;
+        /**
+          * The start character offset of the symbol (on the line provided by the references request).
+          */
+        symbolStartOffset: number;
+        /**
+          * The full display name of the symbol.
+          */
+        symbolDisplayString: string;
+    }
+    /**
+      * Response to "references" request.
+      */
+    interface ReferencesResponse extends Response {
+        body?: ReferencesResponseBody;
+    }
+    /**
+     * Argument for RenameRequest request.
+     */
+    interface RenameRequestArgs extends FileLocationRequestArgs {
+        /**
+         * Should text at specified location be found/changed in comments?
+         */
+        findInComments?: boolean;
+        /**
+         * Should text at specified location be found/changed in strings?
+         */
+        findInStrings?: boolean;
+    }
+    /**
+      * Rename request; value of command field is "rename". Return
+      * response giving the file locations that reference the symbol
+      * found in file at location line, col. Also return full display
+      * name of the symbol so that client can print it unambiguously.
+      */
+    interface RenameRequest extends FileLocationRequest {
+        command: CommandTypes.Rename;
+        arguments: RenameRequestArgs;
+    }
+    /**
+      * Information about the item to be renamed.
+      */
+    interface RenameInfo {
+        /**
+          * True if item can be renamed.
+          */
+        canRename: boolean;
+        /**
+          * Error message if item can not be renamed.
+          */
+        localizedErrorMessage?: string;
+        /**
+          * Display name of the item to be renamed.
+          */
+        displayName: string;
+        /**
+          * Full display name of item to be renamed.
+          */
+        fullDisplayName: string;
+        /**
+          * The items's kind (such as 'className' or 'parameterName' or plain 'text').
+          */
+        kind: string;
+        /**
+          * Optional modifiers for the kind (such as 'public').
+          */
+        kindModifiers: string;
+    }
+    /**
+     *  A group of text spans, all in 'file'.
+     */
+    interface SpanGroup {
+        /** The file to which the spans apply */
+        file: string;
+        /** The text spans in this group */
+        locs: TextSpan[];
+    }
+    interface RenameResponseBody {
+        /**
+         * Information about the item to be renamed.
+         */
+        info: RenameInfo;
+        /**
+         * An array of span groups (one per file) that refer to the item to be renamed.
+         */
+        locs: SpanGroup[];
+    }
+    /**
+      * Rename response message.
+      */
+    interface RenameResponse extends Response {
+        body?: RenameResponseBody;
+    }
+    /**
+     * Represents a file in external project.
+     * External project is project whose set of files, compilation options and open\close state
+     * is maintained by the client (i.e. if all this data come from .csproj file in Visual Studio).
+     * External project will exist even if all files in it are closed and should be closed explicity.
+     * If external project includes one or more tsconfig.json/jsconfig.json files then tsserver will
+     * create configured project for every config file but will maintain a link that these projects were created
+     * as a result of opening external project so they should be removed once external project is closed.
+     */
+    interface ExternalFile {
+        /**
+         * Name of file file
+         */
+        fileName: string;
+        /**
+         * Script kind of the file
+         */
+        scriptKind?: ScriptKindName | ts.ScriptKind;
+        /**
+         * Whether file has mixed content (i.e. .cshtml file that combines html markup with C#/JavaScript)
+         */
+        hasMixedContent?: boolean;
+        /**
+         * Content of the file
+         */
+        content?: string;
+    }
+    /**
+     * Represent an external project
+     */
+    interface ExternalProject {
+        /**
+         * Project name
+         */
+        projectFileName: string;
+        /**
+         * List of root files in project
+         */
+        rootFiles: ExternalFile[];
+        /**
+         * Compiler options for the project
+         */
+        options: ExternalProjectCompilerOptions;
+        /**
+         * @deprecated typingOptions. Use typeAcquisition instead
+         */
+        typingOptions?: TypeAcquisition;
+        /**
+         * Explicitly specified type acquisition for the project
+         */
+        typeAcquisition?: TypeAcquisition;
+    }
+    interface CompileOnSaveMixin {
+        /**
+         * If compile on save is enabled for the project
+         */
+        compileOnSave?: boolean;
+    }
+    /**
+     * For external projects, some of the project settings are sent together with
+     * compiler settings.
+     */
+    type ExternalProjectCompilerOptions = CompilerOptions & CompileOnSaveMixin;
+    /**
+     * Represents a set of changes that happen in project
+     */
+    interface ProjectChanges {
+        /**
+         * List of added files
+         */
+        added: string[];
+        /**
+         * List of removed files
+         */
+        removed: string[];
+        /**
+         * List of updated files
+         */
+        updated: string[];
+    }
+    /**
+      * Information found in a configure request.
+      */
+    interface ConfigureRequestArguments {
+        /**
+          * Information about the host, for example 'Emacs 24.4' or
+          * 'Sublime Text version 3075'
+          */
+        hostInfo?: string;
+        /**
+          * If present, tab settings apply only to this file.
+          */
+        file?: string;
+        /**
+         * The format options to use during formatting and other code editing features.
+         */
+        formatOptions?: FormatCodeSettings;
+        /**
+         * The host's additional supported file extensions
+         */
+        extraFileExtensions?: FileExtensionInfo[];
+    }
+    /**
+      *  Configure request; value of command field is "configure".  Specifies
+      *  host information, such as host type, tab size, and indent size.
+      */
+    interface ConfigureRequest extends Request {
+        command: CommandTypes.Configure;
+        arguments: ConfigureRequestArguments;
+    }
+    /**
+      * Response to "configure" request.  This is just an acknowledgement, so
+      * no body field is required.
+      */
+    interface ConfigureResponse extends Response {
+    }
+    /**
+      *  Information found in an "open" request.
+      */
+    interface OpenRequestArgs extends FileRequestArgs {
+        /**
+         * Used when a version of the file content is known to be more up to date than the one on disk.
+         * Then the known content will be used upon opening instead of the disk copy
+         */
+        fileContent?: string;
+        /**
+         * Used to specify the script kind of the file explicitly. It could be one of the following:
+         *      "TS", "JS", "TSX", "JSX"
+         */
+        scriptKindName?: ScriptKindName;
+    }
+    type ScriptKindName = "TS" | "JS" | "TSX" | "JSX";
+    /**
+      * Open request; value of command field is "open". Notify the
+      * server that the client has file open.  The server will not
+      * monitor the filesystem for changes in this file and will assume
+      * that the client is updating the server (using the change and/or
+      * reload messages) when the file changes. Server does not currently
+      * send a response to an open request.
+      */
+    interface OpenRequest extends Request {
+        command: CommandTypes.Open;
+        arguments: OpenRequestArgs;
+    }
+    /**
+     * Request to open or update external project
+     */
+    interface OpenExternalProjectRequest extends Request {
+        command: CommandTypes.OpenExternalProject;
+        arguments: OpenExternalProjectArgs;
+    }
+    /**
+     * Arguments to OpenExternalProjectRequest request
+     */
+    type OpenExternalProjectArgs = ExternalProject;
+    /**
+     * Request to open multiple external projects
+     */
+    interface OpenExternalProjectsRequest extends Request {
+        command: CommandTypes.OpenExternalProjects;
+        arguments: OpenExternalProjectsArgs;
+    }
+    /**
+     * Arguments to OpenExternalProjectsRequest
+     */
+    interface OpenExternalProjectsArgs {
+        /**
+         * List of external projects to open or update
+         */
+        projects: ExternalProject[];
+    }
+    /**
+     * Response to OpenExternalProjectRequest request. This is just an acknowledgement, so
+     * no body field is required.
+     */
+    interface OpenExternalProjectResponse extends Response {
+    }
+    /**
+     * Response to OpenExternalProjectsRequest request. This is just an acknowledgement, so
+     * no body field is required.
+     */
+    interface OpenExternalProjectsResponse extends Response {
+    }
+    /**
+     * Request to close external project.
+     */
+    interface CloseExternalProjectRequest extends Request {
+        command: CommandTypes.CloseExternalProject;
+        arguments: CloseExternalProjectRequestArgs;
+    }
+    /**
+     * Arguments to CloseExternalProjectRequest request
+     */
+    interface CloseExternalProjectRequestArgs {
+        /**
+         * Name of the project to close
+         */
+        projectFileName: string;
+    }
+    /**
+     * Response to CloseExternalProjectRequest request. This is just an acknowledgement, so
+     * no body field is required.
+     */
+    interface CloseExternalProjectResponse extends Response {
+    }
+    /**
+     * Request to set compiler options for inferred projects.
+     * External projects are opened / closed explicitly.
+     * Configured projects are opened when user opens loose file that has 'tsconfig.json' or 'jsconfig.json' anywhere in one of containing folders.
+     * This configuration file will be used to obtain a list of files and configuration settings for the project.
+     * Inferred projects are created when user opens a loose file that is not the part of external project
+     * or configured project and will contain only open file and transitive closure of referenced files if 'useOneInferredProject' is false,
+     * or all open loose files and its transitive closure of referenced files if 'useOneInferredProject' is true.
+     */
+    interface SetCompilerOptionsForInferredProjectsRequest extends Request {
+        command: CommandTypes.CompilerOptionsForInferredProjects;
+        arguments: SetCompilerOptionsForInferredProjectsArgs;
+    }
+    /**
+     * Argument for SetCompilerOptionsForInferredProjectsRequest request.
+     */
+    interface SetCompilerOptionsForInferredProjectsArgs {
+        /**
+         * Compiler options to be used with inferred projects.
+         */
+        options: ExternalProjectCompilerOptions;
+    }
+    /**
+      * Response to SetCompilerOptionsForInferredProjectsResponse request. This is just an acknowledgement, so
+      * no body field is required.
+      */
+    interface SetCompilerOptionsForInferredProjectsResponse extends Response {
+    }
+    /**
+      *  Exit request; value of command field is "exit".  Ask the server process
+      *  to exit.
+      */
+    interface ExitRequest extends Request {
+        command: CommandTypes.Exit;
+    }
+    /**
+      * Close request; value of command field is "close". Notify the
+      * server that the client has closed a previously open file.  If
+      * file is still referenced by open files, the server will resume
+      * monitoring the filesystem for changes to file.  Server does not
+      * currently send a response to a close request.
+      */
+    interface CloseRequest extends FileRequest {
+        command: CommandTypes.Close;
+    }
+    /**
+     * Request to obtain the list of files that should be regenerated if target file is recompiled.
+     * NOTE: this us query-only operation and does not generate any output on disk.
+     */
+    interface CompileOnSaveAffectedFileListRequest extends FileRequest {
+        command: CommandTypes.CompileOnSaveAffectedFileList;
+    }
+    /**
+     * Contains a list of files that should be regenerated in a project
+     */
+    interface CompileOnSaveAffectedFileListSingleProject {
+        /**
+         * Project name
+         */
+        projectFileName: string;
+        /**
+         * List of files names that should be recompiled
+         */
+        fileNames: string[];
+    }
+    /**
+     * Response for CompileOnSaveAffectedFileListRequest request;
+     */
+    interface CompileOnSaveAffectedFileListResponse extends Response {
+        body: CompileOnSaveAffectedFileListSingleProject[];
+    }
+    /**
+     * Request to recompile the file. All generated outputs (.js, .d.ts or .js.map files) is written on disk.
+     */
+    interface CompileOnSaveEmitFileRequest extends FileRequest {
+        command: CommandTypes.CompileOnSaveEmitFile;
+        arguments: CompileOnSaveEmitFileRequestArgs;
+    }
+    /**
+     * Arguments for CompileOnSaveEmitFileRequest
+     */
+    interface CompileOnSaveEmitFileRequestArgs extends FileRequestArgs {
+        /**
+         * if true - then file should be recompiled even if it does not have any changes.
+         */
+        forced?: boolean;
+    }
+    /**
+      * Quickinfo request; value of command field is
+      * "quickinfo". Return response giving a quick type and
+      * documentation string for the symbol found in file at location
+      * line, col.
+      */
+    interface QuickInfoRequest extends FileLocationRequest {
+        command: CommandTypes.Quickinfo;
+    }
+    /**
+      * Body of QuickInfoResponse.
+      */
+    interface QuickInfoResponseBody {
+        /**
+          * The symbol's kind (such as 'className' or 'parameterName' or plain 'text').
+          */
+        kind: string;
+        /**
+          * Optional modifiers for the kind (such as 'public').
+          */
+        kindModifiers: string;
+        /**
+          * Starting file location of symbol.
+          */
+        start: Location;
+        /**
+          * One past last character of symbol.
+          */
+        end: Location;
+        /**
+          * Type and kind of symbol.
+          */
+        displayString: string;
+        /**
+          * Documentation associated with symbol.
+          */
+        documentation: string;
+        /**
+         * 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?: CodeAction[];
+    }
+    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[];
+    }
+    /**
+      * 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;
+    }
+    /**
+      * Arguments for completions messages.
+      */
+    interface CompletionsRequestArgs extends FileLocationRequestArgs {
+        /**
+          * Optional prefix to apply to possible completions.
+          */
+        prefix?: string;
+    }
+    /**
+      * 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;
+        arguments: CompletionsRequestArgs;
+    }
+    /**
+      * Arguments for completion details request.
+      */
+    interface CompletionDetailsRequestArgs extends FileLocationRequestArgs {
+        /**
+          * Names of one or more entries for which to obtain details.
+          */
+        entryNames: 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: string;
+        /**
+          * 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;
+        /**
+         * 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.
+         */
+        replacementSpan?: TextSpan;
+    }
+    /**
+      * 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: string;
+        /**
+          * 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[];
+    }
+    interface CompletionsResponse extends Response {
+        body?: 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;
+    }
+    /**
+     * Arguments of a signature help request.
+     */
+    interface SignatureHelpRequestArgs extends FileLocationRequestArgs {
+    }
+    /**
+      * 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[];
+    }
+    /**
+      * 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;
+    }
+    /**
+      * 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 error code of the diagnostic message.
+          */
+        code?: number;
+    }
+    interface DiagnosticEventBody {
+        /**
+          * The file for which diagnostic information is reported.
+          */
+        file: string;
+        /**
+          * An array of diagnostic information items.
+          */
+        diagnostics: Diagnostic[];
+    }
+    /**
+      * Event message for "syntaxDiag" and "semanticDiag" event types.
+      * These events provide syntactic and semantic errors for a file.
+      */
+    interface DiagnosticEvent extends Event {
+        body?: DiagnosticEventBody;
+    }
+    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: Diagnostic[];
+    }
+    /**
+     * 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;
+    }
+    /**
+      * 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 {
+        /**
+          * The symbol's name.
+          */
+        name: string;
+        /**
+          * The symbol's kind (such as 'className' or 'parameterName').
+          */
+        kind: string;
+        /**
+          * 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;
+        /**
+          * The file in which the symbol is found.
+          */
+        file: string;
+        /**
+          * The location within file at which the symbol is found.
+          */
+        start: Location;
+        /**
+          * One past the last character of the symbol.
+          */
+        end: Location;
+        /**
+          * 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?: string;
+    }
+    /**
+      * 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: string;
+        /**
+          * 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: string;
+        kindModifiers: string;
+        spans: TextSpan[];
+        childItems?: NavigationTree[];
+    }
+    type TelemetryEventName = "telemetry";
+    interface TelemetryEvent extends Event {
+        event: TelemetryEventName;
+        body: TelemetryEventBody;
+    }
+    interface TelemetryEventBody {
+        telemetryEventName: string;
+        payload: any;
+    }
+    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;
+    }
+    namespace IndentStyle {
+        type None = "None";
+        type Block = "Block";
+        type Smart = "Smart";
+    }
+    type IndentStyle = IndentStyle.None | IndentStyle.Block | IndentStyle.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;
+        insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces?: boolean;
+        insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces?: boolean;
+        insertSpaceBeforeFunctionParenthesis?: boolean;
+        placeOpenBraceOnNewLineForFunctions?: boolean;
+        placeOpenBraceOnNewLineForControlBlocks?: boolean;
+    }
+    interface CompilerOptions {
+        allowJs?: boolean;
+        allowSyntheticDefaultImports?: boolean;
+        allowUnreachableCode?: boolean;
+        allowUnusedLabels?: boolean;
+        baseUrl?: string;
+        charset?: string;
+        declaration?: boolean;
+        declarationDir?: string;
+        disableSizeLimit?: boolean;
+        emitBOM?: boolean;
+        emitDecoratorMetadata?: boolean;
+        experimentalDecorators?: boolean;
+        forceConsistentCasingInFileNames?: 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[]>;
+        preserveConstEnums?: boolean;
+        project?: string;
+        reactNamespace?: string;
+        removeComments?: boolean;
+        rootDir?: string;
+        rootDirs?: string[];
+        skipLibCheck?: boolean;
+        skipDefaultLibCheck?: boolean;
+        sourceMap?: boolean;
+        sourceRoot?: string;
+        strictNullChecks?: boolean;
+        suppressExcessPropertyErrors?: boolean;
+        suppressImplicitAnyIndexErrors?: boolean;
+        target?: ScriptTarget | ts.ScriptTarget;
+        traceResolution?: boolean;
+        types?: string[];
+        /** Paths used to used to compute primary types search locations */
+        typeRoots?: string[];
+        [option: string]: CompilerOptionsValue | undefined;
+    }
+    namespace JsxEmit {
+        type None = "None";
+        type Preserve = "Preserve";
+        type React = "React";
+    }
+    type JsxEmit = JsxEmit.None | JsxEmit.Preserve | JsxEmit.React;
+    namespace ModuleKind {
+        type None = "None";
+        type CommonJS = "CommonJS";
+        type AMD = "AMD";
+        type UMD = "UMD";
+        type System = "System";
+        type ES6 = "ES6";
+        type ES2015 = "ES2015";
+    }
+    type ModuleKind = ModuleKind.None | ModuleKind.CommonJS | ModuleKind.AMD | ModuleKind.UMD | ModuleKind.System | ModuleKind.ES6 | ModuleKind.ES2015;
+    namespace ModuleResolutionKind {
+        type Classic = "Classic";
+        type Node = "Node";
+    }
+    type ModuleResolutionKind = ModuleResolutionKind.Classic | ModuleResolutionKind.Node;
+    namespace NewLineKind {
+        type Crlf = "Crlf";
+        type Lf = "Lf";
+    }
+    type NewLineKind = NewLineKind.Crlf | NewLineKind.Lf;
+    namespace ScriptTarget {
+        type ES3 = "ES3";
+        type ES5 = "ES5";
+        type ES6 = "ES6";
+        type ES2015 = "ES2015";
+    }
+    type ScriptTarget = ScriptTarget.ES3 | ScriptTarget.ES5 | ScriptTarget.ES6 | ScriptTarget.ES2015;
+}
+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;
+    }
+
+    interface TypeAcquisition {
+        enableAutoDiscovery?: boolean;
+        enable?: boolean;
+        include?: string[];
+        exclude?: string[];
+        [option: string]: string[] | boolean | undefined;
+    }
+
+    interface FileExtensionInfo {
+        extension: string;
+        scriptKind: ScriptKind;
+        isMixedContent: boolean;
+    }
+
+    interface JSDocTagInfo {
+        name: string;
+        text?: string;
+    }
+
+    interface MapLike<T> {
+        [index: string]: T;
+    }
+
+    type CompilerOptionsValue = string | number | boolean | (string | number)[] | string[] | MapLike<string[]>;
+}
+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;