protocol.ts

/**
  * Declaration module describing the TypeScript Server protocol
  */
namespace ts.server.protocol {
    export namespace CommandTypes {
        export type Brace = "brace";
        /* @internal */
        export type BraceFull = "brace-full";
        export type BraceCompletion = "braceCompletion";
        export type Change = "change";
        export type Close = "close";
        export type Completions = "completions";
        /* @internal */
        export type CompletionsFull = "completions-full";
        export type CompletionDetails = "completionEntryDetails";
        export type CompileOnSaveAffectedFileList = "compileOnSaveAffectedFileList";
        export type CompileOnSaveEmitFile = "compileOnSaveEmitFile";
        export type Configure = "configure";
        export type Definition = "definition";
        /* @internal */
        export type DefinitionFull = "definition-full";
        export type Implementation = "implementation";
        /* @internal */
        export type ImplementationFull = "implementation-full";
        export type Exit = "exit";
        export type Format = "format";
        export type Formatonkey = "formatonkey";
        /* @internal */
        export type FormatFull = "format-full";
        /* @internal */
        export type FormatonkeyFull = "formatonkey-full";
        /* @internal */
        export type FormatRangeFull = "formatRange-full";
        export type Geterr = "geterr";
        export type GeterrForProject = "geterrForProject";
        export type SemanticDiagnosticsSync = "semanticDiagnosticsSync";
        export type SyntacticDiagnosticsSync = "syntacticDiagnosticsSync";
        export type NavBar = "navbar";
        /* @internal */
        export type NavBarFull = "navbar-full";
        export type Navto = "navto";
        /* @internal */
        export type NavtoFull = "navto-full";
        export type NavTree = "navtree";
        export type NavTreeFull = "navtree-full";
        export type Occurrences = "occurrences";
        export type DocumentHighlights = "documentHighlights";
        /* @internal */
        export type DocumentHighlightsFull = "documentHighlights-full";
        export type Open = "open";
        export type Quickinfo = "quickinfo";
        /* @internal */
        export type QuickinfoFull = "quickinfo-full";
        export type References = "references";
        /* @internal */
        export type ReferencesFull = "references-full";
        export type Reload = "reload";
        export type Rename = "rename";
        /* @internal */
        export type RenameInfoFull = "rename-full";
        /* @internal */
        export type RenameLocationsFull = "renameLocations-full";
        export type Saveto = "saveto";
        export type SignatureHelp = "signatureHelp";
        /* @internal */
        export type SignatureHelpFull = "signatureHelp-full";
        export type TypeDefinition = "typeDefinition";
        export type ProjectInfo = "projectInfo";
        export type ReloadProjects = "reloadProjects";
        export type Unknown = "unknown";
        export type OpenExternalProject = "openExternalProject";
        export type OpenExternalProjects = "openExternalProjects";
        export type CloseExternalProject = "closeExternalProject";
        /* @internal */
        export type SynchronizeProjectList = "synchronizeProjectList";
        /* @internal */
        export type ApplyChangedToOpenFiles = "applyChangedToOpenFiles";
        /* @internal */
        export type EncodedSemanticClassificationsFull = "encodedSemanticClassifications-full";
        /* @internal */
        export type Cleanup = "cleanup";
        /* @internal */
        export type OutliningSpans = "outliningSpans";
        export type TodoComments = "todoComments";
        export type Indentation = "indentation";
        export type DocCommentTemplate = "docCommentTemplate";
        /* @internal */
        export type CompilerOptionsDiagnosticsFull = "compilerOptionsDiagnostics-full";
        /* @internal */
        export type NameOrDottedNameSpan = "nameOrDottedNameSpan";
        /* @internal */
        export type BreakpointStatement = "breakpointStatement";
        export type CompilerOptionsForInferredProjects = "compilerOptionsForInferredProjects";
        export type GetCodeFixes = "getCodeFixes";
        /* @internal */
        export type GetCodeFixesFull = "getCodeFixes-full";
        export type GetSupportedCodeFixes = "getSupportedCodeFixes";
    }

    /**
      * A TypeScript Server message
      */
    export interface Message {
        /**
          * Sequence number of the message
          */
        seq: number;

        /**
          * One of "request", "response", or "event"
          */
        type: "request" | "response" | "event";
    }

    /**
      * Client-initiated request message
      */
    export 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
      */
    export interface ReloadProjectsRequest extends Message {
        command: CommandTypes.ReloadProjects;
    }

    /**
      * Server-initiated event message
      */
    export interface Event extends Message {
        /**
          * Name of event
          */
        event: string;

        /**
          * Event-specific information
          */
        body?: any;
    }

    /**
      * Response by server to client request message.
      */
    export 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.
      */
    export interface FileRequestArgs {
        /**
          * The file for the request (absolute pathname required).
          */
        file: string;

        /*
         * Optional name of project that contains file
         */
        projectFileName?: string;
    }

    /**
     * Requests a JS Doc comment template for a given position
     */
    export interface DocCommentTemplateRequest extends FileLocationRequest {
        command: CommandTypes.DocCommentTemplate;
    }

    /**
     * Response to DocCommentTemplateRequest
     */
    export interface DocCommandTemplateResponse extends Response {
        body?: TextInsertion;
    }

    /**
     * A request to get TODO comments from the file
     */
    export interface TodoCommentRequest extends FileRequest {
        command: CommandTypes.TodoComments;
        arguments: TodoCommentRequestArgs;
    }

    /**
     * Arguments for TodoCommentRequest request.
     */
    export interface TodoCommentRequestArgs extends FileRequestArgs {
        /**
         * Array of target TodoCommentDescriptors that describes TODO comments to be found
         */
        descriptors: TodoCommentDescriptor[];
    }

    /**
     * Response for TodoCommentRequest request.
     */
    export interface TodoCommentsResponse extends Response {
        body?: TodoComment[];
    }

    /**
     * Request to obtain outlining spans in file.
     */
    /* @internal */
    export interface OutliningSpansRequest extends FileRequest {
        command: CommandTypes.OutliningSpans;
    }

    /**
     * Response to OutliningSpansRequest request.
     */
    /* @internal */
    export interface OutliningSpansResponse extends Response {
        body?: OutliningSpan[];
    }

    /**
     * A request to get indentation for a location in file
     */
    export interface IndentationRequest extends FileLocationRequest {
        command: CommandTypes.Indentation;
        arguments: IndentationRequestArgs;
    }

    /**
     * Response for IndentationRequest request.
     */
    export interface IndentationResponse extends Response {
        body?: IndentationResult;
    }

    /**
     * Indentation result representing where indentation should be placed
     */
    export 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.
     */
    export 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.
      */
    export 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.
      */
    export interface ProjectInfoRequest extends Request {
        command: CommandTypes.ProjectInfo;
        arguments: ProjectInfoRequestArgs;
    }

    /**
     * A request to retrieve compiler options diagnostics for a project
     */
    export interface CompilerOptionsDiagnosticsRequest extends Request {
        arguments: CompilerOptionsDiagnosticsRequestArgs;
    }

    /**
     * Arguments for CompilerOptionsDiagnosticsRequest request.
     */
    export interface CompilerOptionsDiagnosticsRequestArgs {
        /**
         * Name of the project to retrieve compiler options diagnostics.
         */
        projectFileName: string;
    }

    /**
      * Response message body for "projectInfo" request
      */
    export 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.
     */
    export interface DiagnosticWithLinePosition {
        message: string;
        start: number;
        length: number;
        startLocation: Location;
        endLocation: Location;
        category: string;
        code: number;
    }

    /**
      * Response message for "projectInfo" request
      */
    export interface ProjectInfoResponse extends Response {
        body?: ProjectInfo;
    }

    /**
      * Request whose sole parameter is a file name.
      */
    export 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.
      */
    export 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;

        /**
         * Position (can be specified instead of line/offset pair)
         */
        /* @internal */
        position?: number;
    }

    /**
      * Request for the available codefixes at a specific position.
      */
    export interface CodeFixRequest extends Request {
        command: CommandTypes.GetCodeFixes;
        arguments: CodeFixRequestArgs;
    }

    /**
      * Instances of this interface specify errorcodes on a specific location in a sourcefile.
      */
    export 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;

        /**
         * Position (can be specified instead of line/offset pair)
         */
        /* @internal */
        startPosition?: number;

        /**
          * The line number for the request (1-based).
          */
        endLine: number;

        /**
          * The character offset (on the line) for the request (1-based).
          */
        endOffset: number;

        /**
         * Position (can be specified instead of line/offset pair)
         */
        /* @internal */
        endPosition?: number;

        /**
          * Errorcodes we want to get the fixes for.
          */
        errorCodes?: number[];
    }

    /**
     * Response for GetCodeFixes request.
     */
    export interface GetCodeFixesResponse extends Response {
        body?: CodeAction[];
    }

    /**
      * A request whose arguments specify a file location (file, line, col).
      */
    export interface FileLocationRequest extends FileRequest {
        arguments: FileLocationRequestArgs;
    }

    /**
     * A request to get codes of supported code fixes.
     */
    export interface GetSupportedCodeFixesRequest extends Request {
        command: CommandTypes.GetSupportedCodeFixes;
    }

    /**
     * A response for GetSupportedCodeFixesRequest request.
     */
    export interface GetSupportedCodeFixesResponse extends Response {
        /**
         * List of error codes supported by the server.
         */
        body?: string[];
    }

    /**
     * A request to get encoded semantic classifications for a span in the file
     */
    /** @internal */
    export interface EncodedSemanticClassificationsRequest extends FileRequest {
        arguments: EncodedSemanticClassificationsRequestArgs;
    }

    /**
     * Arguments for EncodedSemanticClassificationsRequest request.
     */
    export 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.
      */
    export 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.
      */
    export 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.
      */
    export 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.
      */
    export interface ImplementationRequest extends FileLocationRequest {
        command: CommandTypes.Implementation;
    }

    /**
      * Location in source code expressed as (one-based) line and character offset.
      */
    export interface Location {
        line: number;
        offset: number;
    }

    /**
      * Object found in response messages defining a span of text in source code.
      */
    export 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.
      */
    export interface FileSpan extends TextSpan {
        /**
          * File containing text span.
          */
        file: string;
    }

    /**
      * Definition response message.  Gives text range for definition.
      */
    export interface DefinitionResponse extends Response {
        body?: FileSpan[];
    }

    /**
      * Definition response message.  Gives text range for definition.
      */
    export interface TypeDefinitionResponse extends Response {
        body?: FileSpan[];
    }

    /**
      * Implementation response message.  Gives text range for implementations.
      */
    export interface ImplementationResponse extends Response {
        body?: FileSpan[];
    }

    /**
     * Request to get brace completion for a location in the file.
     */
    export interface BraceCompletionRequest extends FileLocationRequest {
        command: CommandTypes.BraceCompletion;
        arguments: BraceCompletionRequestArgs;
    }

    /**
     * Argument for BraceCompletionRequest request.
     */
    export 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.
      */
    export interface OccurrencesRequest extends FileLocationRequest {
        command: CommandTypes.Occurrences;
    }

    export interface OccurrencesResponseItem extends FileSpan {
        /**
          * True if the occurrence is a write location, false otherwise.
          */
        isWriteAccess: boolean;
    }

    export 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.
      */
    export 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.
     */
    export interface HighlightSpan extends TextSpan {
        kind: string;
    }

    /**
     * Represents a set of highligh spans for a give name
     */
    export interface DocumentHighlightsItem {
        /**
          * File containing highlight spans.
          */
        file: string;

        /**
          * Spans to highlight in file.
          */
        highlightSpans: HighlightSpan[];
    }

    /**
     * Response for a DocumentHighlightsRequest request.
     */
    export 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.
      */
    export interface ReferencesRequest extends FileLocationRequest {
        command: CommandTypes.References;
    }

    export 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.
      */
    export 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.
      */
    export interface ReferencesResponse extends Response {
        body?: ReferencesResponseBody;
    }

    /**
     * Argument for RenameRequest request.
     */
    export 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.
      */
    export interface RenameRequest extends FileLocationRequest {
        command: CommandTypes.Rename;
        arguments: RenameRequestArgs;
    }

    /**
      * Information about the item to be renamed.
      */
    export 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'.
     */
    export interface SpanGroup {
        /** The file to which the spans apply */
        file: string;
        /** The text spans in this group */
        locs: TextSpan[];
    }

    export 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.
      */
    export 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.
     */
    export 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
     */
    export 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;
    }

    export 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.
     */
    export type ExternalProjectCompilerOptions = CompilerOptions & CompileOnSaveMixin;

    /**
     * Contains information about current project version
     */
    /* @internal */
    export interface ProjectVersionInfo {
        /**
         * Project name
         */
        projectName: string;
        /**
         * true if project is inferred or false if project is external or configured
         */
        isInferred: boolean;
        /**
         * Project version
         */
        version: number;
        /**
         * Current set of compiler options for project
         */
        options: ts.CompilerOptions;

        /**
         * true if project language service is disabled
         */
        languageServiceDisabled: boolean;
    }

    /**
     * Represents a set of changes that happen in project
     */
    export interface ProjectChanges {
        /**
         * List of added files
         */
        added: string[];
        /**
         * List of removed files
         */
        removed: string[];
        /**
         * List of updated files
         */
        updated: string[];
    }

    /**
     * Describes set of files in the project.
     * info might be omitted in case of inferred projects
     * if files is set - then this is the entire set of files in the project
     * if changes is set - then this is the set of changes that should be applied to existing project
     * otherwise - assume that nothing is changed
     */
    /* @internal */
    export interface ProjectFiles {
        /**
         * Information abount project verison
         */
        info?: ProjectVersionInfo;
        /**
         * List of files in project (might be omitted if current state of project can be computed using only information from 'changes')
         */
        files?: string[];
        /**
         * Set of changes in project (omitted if the entire set of files in project should be replaced)
         */
        changes?: ProjectChanges;
    }

    /**
     * Combines project information with project level errors.
     */
    /* @internal */
    export interface ProjectFilesWithDiagnostics extends ProjectFiles {
        /**
         * List of errors in project
         */
        projectErrors: DiagnosticWithLinePosition[];
    }

    /**
     * Represents set of changes in open file
     */
    /* @internal */
    export interface ChangedOpenFile {
        /**
         * Name of file
         */
        fileName: string;
        /**
         * List of changes that should be applied to known open file
         */
        changes: ts.TextChange[];
    }


    /**
      * Information found in a configure request.
      */
    export 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.
         */