protocol.ts

importtype*astsfrom"./_namespaces/ts.js";
importtype{
ApplicableRefactorInfo,
CompilerOptionsValue,
CompletionsTriggerCharacter,
EndOfLineState,
FileExtensionInfo,
HighlightSpanKind,
InlayHintKind,
InteractiveRefactorArguments,
OutputFile,
RefactorActionInfo,
RefactorTriggerReason,
RenameInfoFailure,
RenameLocation,
ScriptElementKind,
ScriptKind,
SignatureHelpCharacterTypedReason,
SignatureHelpInvokedReason,
SignatureHelpParameter,
SignatureHelpRetriggerCharacter,
SignatureHelpRetriggeredReason,
SignatureHelpTriggerCharacter,
SignatureHelpTriggerReason,
SymbolDisplayPart,
TextChange,
TextInsertion,
TodoComment,
TodoCommentDescriptor,
TypeAcquisition,
UserPreferences,
}from"./_namespaces/ts.js";
import{
ClassificationType,
CompletionTriggerKind,
OrganizeImportsMode,
SemicolonPreference,
}from"./_namespaces/ts.js";

// These types/enums used to be defined in duplicate here and exported. They are re-exported to avoid breaking changes.
export{ApplicableRefactorInfo,ClassificationType,CompletionsTriggerCharacter,CompletionTriggerKind,InlayHintKind,OrganizeImportsMode,RefactorActionInfo,RefactorTriggerReason,RenameInfoFailure,SemicolonPreference,SignatureHelpCharacterTypedReason,SignatureHelpInvokedReason,SignatureHelpParameter,SignatureHelpRetriggerCharacter,SignatureHelpRetriggeredReason,SignatureHelpTriggerCharacter,SignatureHelpTriggerReason,SymbolDisplayPart,UserPreferences};

typeChangeStringIndexSignature<T,NewStringIndexSignatureType>={[KinkeyofT]: stringextendsK ? NewStringIndexSignatureType : T[K];};
typeChangePropertyTypes<T,Substitutionsextends{[KinkeyofT]?: any;}>={
[KinkeyofT]: KextendskeyofSubstitutions ? Substitutions[K] : T[K];
};

// Declaration module describing the TypeScript Server protocol

exportconstenumCommandTypes{
JsxClosingTag="jsxClosingTag",
LinkedEditingRange="linkedEditingRange",
Brace="brace",
/** @internal */
BraceFull="brace-full",
BraceCompletion="braceCompletion",
GetSpanOfEnclosingComment="getSpanOfEnclosingComment",
Change="change",
Close="close",
/** @deprecated Prefer CompletionInfo -- see comment on CompletionsResponse */
Completions="completions",
CompletionInfo="completionInfo",
/** @internal */
CompletionsFull="completions-full",
CompletionDetails="completionEntryDetails",
/** @internal */
CompletionDetailsFull="completionEntryDetails-full",
CompileOnSaveAffectedFileList="compileOnSaveAffectedFileList",
CompileOnSaveEmitFile="compileOnSaveEmitFile",
Configure="configure",
Definition="definition",
/** @internal */
DefinitionFull="definition-full",
DefinitionAndBoundSpan="definitionAndBoundSpan",
/** @internal */
DefinitionAndBoundSpanFull="definitionAndBoundSpan-full",
Implementation="implementation",
/** @internal */
ImplementationFull="implementation-full",
/** @internal */
EmitOutput="emit-output",
Exit="exit",
FileReferences="fileReferences",
/** @internal */
FileReferencesFull="fileReferences-full",
Format="format",
Formatonkey="formatonkey",
/** @internal */
FormatFull="format-full",
/** @internal */
FormatonkeyFull="formatonkey-full",
/** @internal */
FormatRangeFull="formatRange-full",
Geterr="geterr",
GeterrForProject="geterrForProject",
SemanticDiagnosticsSync="semanticDiagnosticsSync",
SyntacticDiagnosticsSync="syntacticDiagnosticsSync",
SuggestionDiagnosticsSync="suggestionDiagnosticsSync",
NavBar="navbar",
/** @internal */
NavBarFull="navbar-full",
Navto="navto",
/** @internal */
NavtoFull="navto-full",
NavTree="navtree",
NavTreeFull="navtree-full",
DocumentHighlights="documentHighlights",
/** @internal */
DocumentHighlightsFull="documentHighlights-full",
Open="open",
Quickinfo="quickinfo",
/** @internal */
QuickinfoFull="quickinfo-full",
References="references",
/** @internal */
ReferencesFull="references-full",
Reload="reload",
Rename="rename",
/** @internal */
RenameInfoFull="rename-full",
/** @internal */
RenameLocationsFull="renameLocations-full",
Saveto="saveto",
SignatureHelp="signatureHelp",
/** @internal */
SignatureHelpFull="signatureHelp-full",
FindSourceDefinition="findSourceDefinition",
Status="status",
TypeDefinition="typeDefinition",
ProjectInfo="projectInfo",
ReloadProjects="reloadProjects",
Unknown="unknown",
OpenExternalProject="openExternalProject",
OpenExternalProjects="openExternalProjects",
CloseExternalProject="closeExternalProject",
/** @internal */
SynchronizeProjectList="synchronizeProjectList",
/** @internal */
ApplyChangedToOpenFiles="applyChangedToOpenFiles",
UpdateOpen="updateOpen",
/** @internal */
EncodedSyntacticClassificationsFull="encodedSyntacticClassifications-full",
/** @internal */
EncodedSemanticClassificationsFull="encodedSemanticClassifications-full",
/** @internal */
Cleanup="cleanup",
GetOutliningSpans="getOutliningSpans",
/** @internal */
GetOutliningSpansFull="outliningSpans",// Full command name is different for backward compatibility purposes
TodoComments="todoComments",
Indentation="indentation",
DocCommentTemplate="docCommentTemplate",
/** @internal */
CompilerOptionsDiagnosticsFull="compilerOptionsDiagnostics-full",
/** @internal */
NameOrDottedNameSpan="nameOrDottedNameSpan",
/** @internal */
BreakpointStatement="breakpointStatement",
CompilerOptionsForInferredProjects="compilerOptionsForInferredProjects",
GetCodeFixes="getCodeFixes",
/** @internal */
GetCodeFixesFull="getCodeFixes-full",
GetCombinedCodeFix="getCombinedCodeFix",
/** @internal */
GetCombinedCodeFixFull="getCombinedCodeFix-full",
ApplyCodeActionCommand="applyCodeActionCommand",
GetSupportedCodeFixes="getSupportedCodeFixes",

GetApplicableRefactors="getApplicableRefactors",
GetEditsForRefactor="getEditsForRefactor",
GetMoveToRefactoringFileSuggestions="getMoveToRefactoringFileSuggestions",
PreparePasteEdits="preparePasteEdits",
GetPasteEdits="getPasteEdits",
/** @internal */
GetEditsForRefactorFull="getEditsForRefactor-full",

OrganizeImports="organizeImports",
/** @internal */
OrganizeImportsFull="organizeImports-full",
GetEditsForFileRename="getEditsForFileRename",
/** @internal */
GetEditsForFileRenameFull="getEditsForFileRename-full",
ConfigurePlugin="configurePlugin",
SelectionRange="selectionRange",
/** @internal */
SelectionRangeFull="selectionRange-full",
ToggleLineComment="toggleLineComment",
/** @internal */
ToggleLineCommentFull="toggleLineComment-full",
ToggleMultilineComment="toggleMultilineComment",
/** @internal */
ToggleMultilineCommentFull="toggleMultilineComment-full",
CommentSelection="commentSelection",
/** @internal */
CommentSelectionFull="commentSelection-full",
UncommentSelection="uncommentSelection",
/** @internal */
UncommentSelectionFull="uncommentSelection-full",
PrepareCallHierarchy="prepareCallHierarchy",
ProvideCallHierarchyIncomingCalls="provideCallHierarchyIncomingCalls",
ProvideCallHierarchyOutgoingCalls="provideCallHierarchyOutgoingCalls",
ProvideInlayHints="provideInlayHints",
WatchChange="watchChange",
MapCode="mapCode",
/** @internal */
CopilotRelated="copilotRelated",
}

/**
 * A TypeScript Server message
 */
exportinterfaceMessage{
/**
 * Sequence number of the message
 */
seq: number;

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

/**
 * Client-initiated request message
 */
exportinterfaceRequestextendsMessage{
type: "request";

/**
 * The command to execute
 */
command: string;

/**
 * Object containing arguments for the command
 */
arguments?: any;
}

/**
 * Request to reload the project structure for all the opened files
 */
exportinterfaceReloadProjectsRequestextendsRequest{
command: CommandTypes.ReloadProjects;
}

/**
 * Server-initiated event message
 */
exportinterfaceEventextendsMessage{
type: "event";

/**
 * Name of event
 */
event: string;

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

/**
 * Response by server to client request message.
 */
exportinterfaceResponseextendsMessage{
type: "response";

/**
 * Sequence number of the request message.
 */
request_seq: number;

/**
 * Outcome of the request.
 */
success: boolean;

/**
 * The command requested.
 */
command: string;

/**
 * If success === false, this should always be provided.
 * Otherwise, may (or may not) contain a success message.
 */
message?: string;

/**
 * Contains message body if success === true.
 */
body?: any;

/**
 * Contains extra information that plugin can include to be passed on
 */
metadata?: unknown;

/**
 * Exposes information about the performance of this request-response pair.
 */
performanceData?: PerformanceData;
}

exportinterfacePerformanceData{
/**
 * Time spent updating the program graph, in milliseconds.
 */
updateGraphDurationMs?: number;
/**
 * The time spent creating or updating the auto-import program, in milliseconds.
 */
createAutoImportProviderProgramDurationMs?: number;
/**
 * The time spent computing diagnostics, in milliseconds.
 */
diagnosticsDuration?: FileDiagnosticPerformanceData[];
}

/**
 * Time spent computing each kind of diagnostics, in milliseconds.
 */
exporttypeDiagnosticPerformanceData={[KindinDiagnosticEventKind]?: number;};

exportinterfaceFileDiagnosticPerformanceDataextendsDiagnosticPerformanceData{
/**
 * The file for which the performance data is reported.
 */
file: string;
}

/**
 * Arguments for FileRequest messages.
 */
exportinterfaceFileRequestArgs{
/**
 * The file for the request (absolute pathname required).
 */
file: string;

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

exportinterfaceStatusRequestextendsRequest{
command: CommandTypes.Status;
}

exportinterfaceStatusResponseBody{
/**
 * The TypeScript version (`ts.version`).
 */
version: string;
}

/**
 * Response to StatusRequest
 */
exportinterfaceStatusResponseextendsResponse{
body: StatusResponseBody;
}

/**
 * Requests a JS Doc comment template for a given position
 */
exportinterfaceDocCommentTemplateRequestextendsFileLocationRequest{
command: CommandTypes.DocCommentTemplate;
}

/**
 * Response to DocCommentTemplateRequest
 */
exportinterfaceDocCommandTemplateResponseextendsResponse{
body?: TextInsertion;
}

/**
 * A request to get TODO comments from the file
 */
exportinterfaceTodoCommentRequestextendsFileRequest{
command: CommandTypes.TodoComments;
arguments: TodoCommentRequestArgs;
}

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

/**
 * Response for TodoCommentRequest request.
 */
exportinterfaceTodoCommentsResponseextendsResponse{
body?: TodoComment[];
}

/**
 * A request to determine if the caret is inside a comment.
 */
exportinterfaceSpanOfEnclosingCommentRequestextendsFileLocationRequest{
command: CommandTypes.GetSpanOfEnclosingComment;
arguments: SpanOfEnclosingCommentRequestArgs;
}

exportinterfaceSpanOfEnclosingCommentRequestArgsextendsFileLocationRequestArgs{
/**
 * Requires that the enclosing span be a multi-line comment, or else the request returns undefined.
 */
onlyMultiLine: boolean;
}

/**
 * Request to obtain outlining spans in file.
 */
exportinterfaceOutliningSpansRequestextendsFileRequest{
command: CommandTypes.GetOutliningSpans;
}

exporttypeOutliningSpan=ChangePropertyTypes<ts.OutliningSpan,{textSpan: TextSpan;hintSpan: TextSpan;}>;

/**
 * Response to OutliningSpansRequest request.
 */
exportinterfaceOutliningSpansResponseextendsResponse{
body?: OutliningSpan[];
}

/**
 * Request to obtain outlining spans in file.
 *
 * @internal
 */
exportinterfaceOutliningSpansRequestFullextendsFileRequest{
command: CommandTypes.GetOutliningSpansFull;
}

/**
 * Response to OutliningSpansRequest request.
 *
 * @internal@knipignore
 */
exportinterfaceOutliningSpansResponseFullextendsResponse{
body?: ts.OutliningSpan[];
}

/**
 * A request to get indentation for a location in file
 */
exportinterfaceIndentationRequestextendsFileLocationRequest{
command: CommandTypes.Indentation;
arguments: IndentationRequestArgs;
}

/**
 * Response for IndentationRequest request.
 */
exportinterfaceIndentationResponseextendsResponse{
body?: IndentationResult;
}

/**
 * Indentation result representing where indentation should be placed
 */
exportinterfaceIndentationResult{
/**
 * 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.
 */
exportinterfaceIndentationRequestArgsextendsFileLocationRequestArgs{
/**
 * 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.
 */
exportinterfaceProjectInfoRequestArgsextendsFileRequestArgs{
/**
 * Indicate if the file name list of the project is needed
 */
needFileNameList: boolean;
/**
 * if true returns details about default configured project calculation
 */
needDefaultConfiguredProjectInfo?: boolean;
}

/**
 * A request to get the project information of the current file.
 */
exportinterfaceProjectInfoRequestextendsRequest{
command: CommandTypes.ProjectInfo;
arguments: ProjectInfoRequestArgs;
}

/**
 * A request to retrieve compiler options diagnostics for a project
 */
exportinterfaceCompilerOptionsDiagnosticsRequestextendsRequest{
arguments: CompilerOptionsDiagnosticsRequestArgs;
}

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

/**
 * Details about the default project for the file if tsconfig file is found
 */
exportinterfaceDefaultConfiguredProjectInfo{
/** List of config files looked and did not match because file was not part of root file names */
notMatchedByConfig?: readonlystring[];
/** List of projects which were loaded but file was not part of the project or is file from referenced project */
notInProject?: readonlystring[];
/** Configured project used as default */
defaultProject?: string;
}

/**
 * Response message body for "projectInfo" request
 */
exportinterfaceProjectInfo{
/**
 * 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;
/**
 * Information about default project
 */
configuredProjectInfo?: DefaultConfiguredProjectInfo;
}

/**
 * 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.
 */
exportinterfaceDiagnosticWithLinePosition{
message: string;
start: number;
length: number;
startLocation: Location;
endLocation: Location;
category: string;
code: number;
/** May store more in future. For now, this will simply be `true` to indicate when a diagnostic is an unused-identifier diagnostic. */
reportsUnnecessary?: {};
reportsDeprecated?: {};
relatedInformation?: DiagnosticRelatedInformation[];
}

/**
 * Response message for "projectInfo" request
 */
exportinterfaceProjectInfoResponseextendsResponse{
body?: ProjectInfo;
}

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

exporttypeFileLocationOrRangeRequestArgs=FileLocationRequestArgs|FileRangeRequestArgs;

/**
 * Request refactorings at a given position or selection area.
 */
exportinterfaceGetApplicableRefactorsRequestextendsRequest{
command: CommandTypes.GetApplicableRefactors;
arguments: GetApplicableRefactorsRequestArgs;
}
exporttypeGetApplicableRefactorsRequestArgs=FileLocationOrRangeRequestArgs&{
triggerReason?: RefactorTriggerReason;
kind?: string;
/**
 * Include refactor actions that require additional arguments to be passed when
 * calling 'GetEditsForRefactor'. When true, clients should inspect the
 * `isInteractive` property of each returned `RefactorActionInfo`
 * and ensure they are able to collect the appropriate arguments for any
 * interactive refactor before offering it.
 */
includeInteractiveActions?: boolean;
};

/**
 * Response is a list of available refactorings.
 * Each refactoring exposes one or more "Actions"; a user selects one action to invoke a refactoring
 */
exportinterfaceGetApplicableRefactorsResponseextendsResponse{
body?: ApplicableRefactorInfo[];
}

/**
 * Request refactorings at a given position or selection area to move to an existing file.
 */
exportinterfaceGetMoveToRefactoringFileSuggestionsRequestextendsRequest{
command: CommandTypes.GetMoveToRefactoringFileSuggestions;
arguments: GetMoveToRefactoringFileSuggestionsRequestArgs;
}
exporttypeGetMoveToRefactoringFileSuggestionsRequestArgs=FileLocationOrRangeRequestArgs&{
kind?: string;
};
/**
 * Response is a list of available files.
 * Each refactoring exposes one or more "Actions"; a user selects one action to invoke a refactoring
 */
exportinterfaceGetMoveToRefactoringFileSuggestionsextendsResponse{
body: {
newFileName: string;
files: string[];
};
}

/**
 * Request to check if `pasteEdits` should be provided for a given location post copying text from that location.
 */
exportinterfacePreparePasteEditsRequestextendsFileRequest{
command: CommandTypes.PreparePasteEdits;
arguments: PreparePasteEditsRequestArgs;
}
exportinterfacePreparePasteEditsRequestArgsextendsFileRequestArgs{
copiedTextSpan: TextSpan[];
}
exportinterfacePreparePasteEditsResponseextendsResponse{
body: boolean;
}

/**
 * Request refactorings at a given position post pasting text from some other location.
 */

exportinterfaceGetPasteEditsRequestextendsRequest{
command: CommandTypes.GetPasteEdits;
arguments: GetPasteEditsRequestArgs;
}

exportinterfaceGetPasteEditsRequestArgsextendsFileRequestArgs{
/** The text that gets pasted in a file. */
pastedText: string[];
/** Locations of where the `pastedText` gets added in a file. If the length of the `pastedText` and `pastedLocations` are not the same,
 * then the `pastedText` is combined into one and added at all the `pastedLocations`.
 */
pasteLocations: TextSpan[];
/** The source location of each `pastedText`. If present, the length of `spans` must be equal to the length of `pastedText`. */
copiedFrom?: {file: string;spans: TextSpan[];};
}

exportinterfaceGetPasteEditsResponseextendsResponse{
body: PasteEditsAction;
}

exportinterfacePasteEditsAction{
edits: FileCodeEdits[];
fixId?: {};
}

exportinterfaceGetEditsForRefactorRequestextendsRequest{
command: CommandTypes.GetEditsForRefactor;
arguments: GetEditsForRefactorRequestArgs;
}

/**
 * Request the edits that a particular refactoring action produces.
 * Callers must specify the name of the refactor and the name of the action.
 */
exporttypeGetEditsForRefactorRequestArgs=FileLocationOrRangeRequestArgs&{
/* The 'name' property from the refactoring that offered this action */
refactor: string;
/* The 'name' property from the refactoring action */
action: string;
/* Arguments for interactive action */
interactiveRefactorArguments?: InteractiveRefactorArguments;
};

exportinterfaceGetEditsForRefactorResponseextendsResponse{
body?: RefactorEditInfo;
}

exportinterfaceRefactorEditInfo{
edits: FileCodeEdits[];

/**
 * An optional location where the editor should start a rename operation once
 * the refactoring edits have been applied
 */
renameLocation?: Location;
renameFilename?: string;
notApplicableReason?: string;
}

/**
 * Organize imports by:
 * 1) Removing unused imports
 * 2) Coalescing imports from the same module
 * 3) Sorting imports
 */
exportinterfaceOrganizeImportsRequestextendsRequest{
command: CommandTypes.OrganizeImports;
arguments: OrganizeImportsRequestArgs;
}

exporttypeOrganizeImportsScope=GetCombinedCodeFixScope;

exportinterfaceOrganizeImportsRequestArgs{
scope: OrganizeImportsScope;
/** @deprecated Use `mode` instead */
skipDestructiveCodeActions?: boolean;
mode?: OrganizeImportsMode;
}

exportinterfaceOrganizeImportsResponseextendsResponse{
body: readonlyFileCodeEdits[];
}

exportinterfaceGetEditsForFileRenameRequestextendsRequest{
command: CommandTypes.GetEditsForFileRename;
arguments: GetEditsForFileRenameRequestArgs;
}

/** Note: Paths may also be directories. */
exportinterfaceGetEditsForFileRenameRequestArgs{
readonlyoldFilePath: string;
readonlynewFilePath: string;
}

exportinterfaceGetEditsForFileRenameResponseextendsResponse{
body: readonlyFileCodeEdits[];
}

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

exportinterfaceGetCombinedCodeFixRequestextendsRequest{
command: CommandTypes.GetCombinedCodeFix;
arguments: GetCombinedCodeFixRequestArgs;
}

exportinterfaceGetCombinedCodeFixResponseextendsResponse{
body: CombinedCodeActions;
}

exportinterfaceApplyCodeActionCommandRequestextendsRequest{
command: CommandTypes.ApplyCodeActionCommand;
arguments: ApplyCodeActionCommandRequestArgs;
}

// All we need is the `success` and `message` fields of Response.
exportinterfaceApplyCodeActionCommandResponseextendsResponse{}

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

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

/**
 * Instances of this interface specify errorcodes on a specific location in a sourcefile.
 */
exportinterfaceCodeFixRequestArgsextendsFileRangeRequestArgs{
/**
 * Errorcodes we want to get the fixes for.
 */
errorCodes: readonlynumber[];
}

exportinterfaceGetCombinedCodeFixRequestArgs{
scope: GetCombinedCodeFixScope;
fixId: {};
}

exportinterfaceGetCombinedCodeFixScope{
type: "file";
args: FileRequestArgs;
}

exportinterfaceApplyCodeActionCommandRequestArgs{
/** May also be an array of commands. */
command: {};
}

/**
 * Response for GetCodeFixes request.
 */
exportinterfaceGetCodeFixesResponseextendsResponse{
body?: CodeAction[];
}

/**
 * A request whose arguments specify a file location (file, line, col).
 */
exportinterfaceFileLocationRequestextendsFileRequest{
arguments: FileLocationRequestArgs;
}

/**
 * A request to get codes of supported code fixes.
 */
exportinterfaceGetSupportedCodeFixesRequestextendsRequest{
command: CommandTypes.GetSupportedCodeFixes;
arguments?: Partial<FileRequestArgs>;
}

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

/**
 * A request to get encoded Syntactic classifications for a span in the file
 *
 * @internal
 */
exportinterfaceEncodedSyntacticClassificationsRequestextendsFileRequest{
arguments: EncodedSyntacticClassificationsRequestArgs;
}

/**
 * Arguments for EncodedSyntacticClassificationsRequest request.
 *
 * @internal
 */
exportinterfaceEncodedSyntacticClassificationsRequestArgsextendsFileRequestArgs{
/**
 * Start position of the span.
 */
start: number;
/**
 * Length of the span.
 */
length: number;
}

/**
 * A request to get encoded semantic classifications for a span in the file
 */
exportinterfaceEncodedSemanticClassificationsRequestextendsFileRequest{
arguments: EncodedSemanticClassificationsRequestArgs;
}

/**
 * Arguments for EncodedSemanticClassificationsRequest request.
 */
exportinterfaceEncodedSemanticClassificationsRequestArgsextendsFileRequestArgs{
/**
 * Start position of the span.
 */
start: number;
/**
 * Length of the span.
 */
length: number;
/**
 * Optional parameter for the semantic highlighting response, if absent it
 * defaults to "original".
 */
format?: "original"|"2020";
}

/** The response for a EncodedSemanticClassificationsRequest */
exportinterfaceEncodedSemanticClassificationsResponseextendsResponse{
body?: EncodedSemanticClassificationsResponseBody;
}

/**
 * Implementation response message. Gives series of text spans depending on the format ar.
 */
exportinterfaceEncodedSemanticClassificationsResponseBody{
endOfLineState: EndOfLineState;
spans: number[];
}
/**
 * Arguments in document highlight request; include: filesToSearch, file,
 * line, offset.
 */
exportinterfaceDocumentHighlightsRequestArgsextendsFileLocationRequestArgs{
/**
 * 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.
 */
exportinterfaceDefinitionRequestextendsFileLocationRequest{
command: CommandTypes.Definition;
}

exportinterfaceDefinitionAndBoundSpanRequestextendsFileLocationRequest{
readonlycommand: CommandTypes.DefinitionAndBoundSpan;
}

exportinterfaceFindSourceDefinitionRequestextendsFileLocationRequest{
readonlycommand: CommandTypes.FindSourceDefinition;
}

exportinterfaceDefinitionAndBoundSpanResponseextendsResponse{
readonlybody: DefinitionInfoAndBoundSpan;
}

/** @internal */
exportinterfaceEmitOutputRequestextendsFileRequest{
command: CommandTypes.EmitOutput;
arguments: EmitOutputRequestArgs;
}
/** @internal */
exportinterfaceEmitOutputRequestArgsextendsFileRequestArgs{
includeLinePosition?: boolean;
/** if true - return response as object with emitSkipped and diagnostics */
richResponse?: boolean;
}
/** @internal */
exportinterfaceEmitOutputResponseextendsResponse{
readonlybody: EmitOutput|ts.EmitOutput;
}