typescript
Version:
TypeScript is a language for application scale JavaScript development
2,886 lines • 90.7 kB
TypeScript
/**
* A special text edit with an additional change annotation.
*
* @since 3.16.0.
*/
export interface AnnotatedTextEdit {
/**
* The range of the text document to be manipulated. To insert
* text into a document create a range where start === end.
*/
range: Range;
/**
* The string to be inserted. For delete operations use an
* empty string.
*/
newText: string;
/**
* The actual identifier of the change annotation
*/
annotationId: ChangeAnnotationIdentifier;
}
/**
* Defines how values from a set of defaults and an individual item will be
* merged.
*
* @since 3.18.0
*/
export type ApplyKind = 1 | 2;
/**
* Represents an incoming call, e.g. a caller of a method or constructor.
*
* @since 3.16.0
*/
export interface CallHierarchyIncomingCall {
/**
* The item that makes the call.
*/
from: CallHierarchyItem;
/**
* The ranges at which the calls appear. This is relative to the caller
* denoted by {@link CallHierarchyIncomingCall.from `this.from`}.
*/
fromRanges: Range[];
}
/**
* The parameter of a `callHierarchy/incomingCalls` request.
*
* @since 3.16.0
*/
export interface CallHierarchyIncomingCallsParams {
/**
* An optional token that a server can use to report work done progress.
*/
workDoneToken?: ProgressToken | undefined;
/**
* An optional token that a server can use to report partial results (e.g. streaming) to
* the client.
*/
partialResultToken?: ProgressToken | undefined;
item: CallHierarchyItem;
}
/**
* Represents programming constructs like functions or constructors in the context
* of call hierarchy.
*
* @since 3.16.0
*/
export interface CallHierarchyItem {
/**
* The name of this item.
*/
name: string;
/**
* The kind of this item.
*/
kind: SymbolKind;
/**
* Tags for this item.
*/
tags?: SymbolTag[] | undefined;
/**
* More detail for this item, e.g. the signature of a function.
*/
detail?: string | undefined;
/**
* The resource identifier of this item.
*/
uri: DocumentUri;
/**
* The range enclosing this symbol not including leading/trailing whitespace but everything else, e.g. comments and code.
*/
range: Range;
/**
* The range that should be selected and revealed when this symbol is being picked, e.g. the name of a function.
* Must be contained by the {@link CallHierarchyItem.range `range`}.
*/
selectionRange: Range;
/**
* A data entry field that is preserved between a call hierarchy prepare and
* incoming calls or outgoing calls requests.
*/
data?: LSPAny | undefined;
}
/**
* Represents an outgoing call, e.g. calling a getter from a method or a method from a constructor etc.
*
* @since 3.16.0
*/
export interface CallHierarchyOutgoingCall {
/**
* The item that is called.
*/
to: CallHierarchyItem;
/**
* The range at which this item is called. This is the range relative to the caller, e.g the item
* passed to {@link CallHierarchyItemProvider.provideCallHierarchyOutgoingCalls `provideCallHierarchyOutgoingCalls`}
* and not {@link CallHierarchyOutgoingCall.to `this.to`}.
*/
fromRanges: Range[];
}
/**
* The parameter of a `callHierarchy/outgoingCalls` request.
*
* @since 3.16.0
*/
export interface CallHierarchyOutgoingCallsParams {
/**
* An optional token that a server can use to report work done progress.
*/
workDoneToken?: ProgressToken | undefined;
/**
* An optional token that a server can use to report partial results (e.g. streaming) to
* the client.
*/
partialResultToken?: ProgressToken | undefined;
item: CallHierarchyItem;
}
/**
* The parameter of a `textDocument/prepareCallHierarchy` request.
*
* @since 3.16.0
*/
export interface CallHierarchyPrepareParams {
/**
* The text document.
*/
textDocument: TextDocumentIdentifier;
/**
* The position inside the text document.
*/
position: Position;
/**
* An optional token that a server can use to report work done progress.
*/
workDoneToken?: ProgressToken | undefined;
}
/**
* Additional information that describes document changes.
*
* @since 3.16.0
*/
export interface ChangeAnnotation {
/**
* A human-readable string describing the actual change. The string
* is rendered prominent in the user interface.
*/
label: string;
/**
* A flag which indicates that user confirmation is needed
* before applying the change.
*/
needsConfirmation?: boolean | undefined;
/**
* A human-readable string which is rendered less prominent in
* the user interface.
*/
description?: string | undefined;
}
/**
* An identifier to refer to a change annotation stored with a workspace edit.
*/
export type ChangeAnnotationIdentifier = string;
/**
* A code action represents a change that can be performed in code, e.g. to fix a problem or
* to refactor code.
*
* A CodeAction must set either `edit` and/or a `command`. If both are supplied, the `edit` is applied first, then the `command` is executed.
*/
export interface CodeAction {
/**
* A short, human-readable, title for this code action.
*/
title: string;
/**
* The kind of the code action.
*
* Used to filter code actions.
*/
kind?: CodeActionKind | undefined;
/**
* The diagnostics that this code action resolves.
*/
diagnostics?: Diagnostic[] | undefined;
/**
* Marks this as a preferred action. Preferred actions are used by the `auto fix` command and can be targeted
* by keybindings.
*
* A quick fix should be marked preferred if it properly addresses the underlying error.
* A refactoring should be marked preferred if it is the most reasonable choice of actions to take.
*
* @since 3.15.0
*/
isPreferred?: boolean | undefined;
/**
* Marks that the code action cannot currently be applied.
*
* Clients should follow the following guidelines regarding disabled code actions:
*
* - Disabled code actions are not shown in automatic [lightbulbs](https://code.visualstudio.com/docs/editor/editingevolved#_code-action)
* code action menus.
*
* - Disabled actions are shown as faded out in the code action menu when the user requests a more specific type
* of code action, such as refactorings.
*
* - If the user has a [keybinding](https://code.visualstudio.com/docs/editor/refactoring#_keybindings-for-code-actions)
* that auto applies a code action and only disabled code actions are returned, the client should show the user an
* error message with `reason` in the editor.
*
* @since 3.16.0
*/
disabled?: CodeActionDisabled | undefined;
/**
* The workspace edit this code action performs.
*/
edit?: WorkspaceEdit | undefined;
/**
* A command this code action executes. If a code action
* provides an edit and a command, first the edit is
* executed and then the command.
*/
command?: Command | undefined;
/**
* A data entry field that is preserved on a code action between
* a `textDocument/codeAction` and a `codeAction/resolve` request.
*
* @since 3.16.0
*/
data?: LSPAny | undefined;
/**
* Tags for this code action.
*
* @since 3.18.0
*/
tags?: CodeActionTag[] | undefined;
}
/**
* Contains additional diagnostic information about the context in which
* a {@link CodeActionProvider.provideCodeActions code action} is run.
*/
export interface CodeActionContext {
/**
* An array of diagnostics known on the client side overlapping the range provided to the
* `textDocument/codeAction` request. They are provided so that the server knows which
* errors are currently presented to the user for the given range. There is no guarantee
* that these accurately reflect the error state of the resource. The primary parameter
* to compute code actions is the provided range.
*/
diagnostics: Diagnostic[];
/**
* Requested kind of actions to return.
*
* Actions not of this kind are filtered out by the client before being shown. So servers
* can omit computing them.
*/
only?: CodeActionKind[] | undefined;
/**
* The reason why code actions were requested.
*
* @since 3.17.0
*/
triggerKind?: CodeActionTriggerKind | undefined;
}
/**
* Captures why the code action is currently disabled.
*
* @since 3.18.0
*/
export interface CodeActionDisabled {
/**
* Human readable description of why the code action is currently disabled.
*
* This is displayed in the code actions UI.
*/
reason: string;
}
/**
* A set of predefined code action kinds
*/
export type CodeActionKind = "" | "quickfix" | "refactor" | "refactor.extract" | "refactor.inline" | "refactor.move" | "refactor.rewrite" | "source" | "source.organizeImports" | "source.fixAll" | "notebook" | string;
/**
* The parameters of a {@link CodeActionRequest}.
*/
export interface CodeActionParams {
/**
* An optional token that a server can use to report work done progress.
*/
workDoneToken?: ProgressToken | undefined;
/**
* An optional token that a server can use to report partial results (e.g. streaming) to
* the client.
*/
partialResultToken?: ProgressToken | undefined;
/**
* The document in which the command was invoked.
*/
textDocument: TextDocumentIdentifier;
/**
* The range for which the command was invoked.
*/
range: Range;
/**
* Context carrying additional information.
*/
context: CodeActionContext;
}
/**
* Code action tags are extra annotations that tweak the behavior of a code action.
*
* @since 3.18.0
*/
export type CodeActionTag = 1;
/**
* The reason why code actions were requested.
*
* @since 3.17.0
*/
export type CodeActionTriggerKind = 1 | 2;
/**
* Structure to capture a description for an error code.
*
* @since 3.16.0
*/
export interface CodeDescription {
/**
* An URI to open with more information about the diagnostic error.
*/
href: URI;
}
/**
* A code lens represents a {@link Command command} that should be shown along with
* source text, like the number of references, a way to run tests, etc.
*
* A code lens is _unresolved_ when no command is associated to it. For performance
* reasons the creation of a code lens and resolving should be done in two stages.
*/
export interface CodeLens {
/**
* The range in which this code lens is valid. Should only span a single line.
*/
range: Range;
/**
* The command this code lens represents.
*/
command?: Command | undefined;
/**
* A data entry field that is preserved on a code lens item between
* a {@link CodeLensRequest} and a {@link CodeLensResolveRequest}
*/
data?: LSPAny | undefined;
}
/**
* The parameters of a {@link CodeLensRequest}.
*/
export interface CodeLensParams {
/**
* An optional token that a server can use to report work done progress.
*/
workDoneToken?: ProgressToken | undefined;
/**
* An optional token that a server can use to report partial results (e.g. streaming) to
* the client.
*/
partialResultToken?: ProgressToken | undefined;
/**
* The document to request code lens for.
*/
textDocument: TextDocumentIdentifier;
}
/**
* Represents a reference to a command. Provides a title which
* will be used to represent a command in the UI and, optionally,
* an array of arguments which will be passed to the command handler
* function when invoked.
*/
export interface Command {
/**
* Title of the command, like `save`.
*/
title: string;
/**
* An optional tooltip.
*
* @since 3.18.0
*/
tooltip?: string | undefined;
/**
* The identifier of the actual command handler.
*/
command: string;
/**
* Arguments that the command handler should be
* invoked with.
*/
arguments?: LSPAny[] | undefined;
}
/**
* Contains additional information about the context in which a completion request is triggered.
*/
export interface CompletionContext {
/**
* How the completion was triggered.
*/
triggerKind: CompletionTriggerKind;
/**
* The trigger character (a single character) that has trigger code complete.
* Is undefined if `triggerKind !== CompletionTriggerKind.TriggerCharacter`
*/
triggerCharacter?: string | undefined;
}
/**
* A completion item represents a text snippet that is
* proposed to complete text that is being typed.
*/
export interface CompletionItem {
/**
* The label of this completion item.
*
* The label property is also by default the text that
* is inserted when selecting this completion.
*
* If label details are provided the label itself should
* be an unqualified name of the completion item.
*/
label: string;
/**
* Additional details for the label
*
* @since 3.17.0
*/
labelDetails?: CompletionItemLabelDetails | undefined;
/**
* The kind of this completion item. Based of the kind
* an icon is chosen by the editor.
*/
kind?: CompletionItemKind | undefined;
/**
* Tags for this completion item.
*
* @since 3.15.0
*/
tags?: CompletionItemTag[] | undefined;
/**
* A human-readable string with additional information
* about this item, like type or symbol information.
*/
detail?: string | undefined;
/**
* A human-readable string that represents a doc-comment.
*/
documentation?: string | MarkupContent | undefined;
/**
* Indicates if this item is deprecated.
* @deprecated Use `tags` instead.
*/
deprecated?: boolean | undefined;
/**
* Select this item when showing.
*
* *Note* that only one completion item can be selected and that the
* tool / client decides which item that is. The rule is that the *first*
* item of those that match best is selected.
*/
preselect?: boolean | undefined;
/**
* A string that should be used when comparing this item
* with other items. When `falsy` the {@link CompletionItem.label label}
* is used.
*/
sortText?: string | undefined;
/**
* A string that should be used when filtering a set of
* completion items. When `falsy` the {@link CompletionItem.label label}
* is used.
*/
filterText?: string | undefined;
/**
* A string that should be inserted into a document when selecting
* this completion. When `falsy` the {@link CompletionItem.label label}
* is used.
*
* The `insertText` is subject to interpretation by the client side.
* Some tools might not take the string literally. For example
* VS Code when code complete is requested in this example
* `con<cursor position>` and a completion item with an `insertText` of
* `console` is provided it will only insert `sole`. Therefore it is
* recommended to use `textEdit` instead since it avoids additional client
* side interpretation.
*/
insertText?: string | undefined;
/**
* The format of the insert text. The format applies to both the
* `insertText` property and the `newText` property of a provided
* `textEdit`. If omitted defaults to `InsertTextFormat.PlainText`.
*
* Please note that the insertTextFormat doesn't apply to
* `additionalTextEdits`.
*/
insertTextFormat?: InsertTextFormat | undefined;
/**
* How whitespace and indentation is handled during completion
* item insertion. If not provided the clients default value depends on
* the `textDocument.completion.insertTextMode` client capability.
*
* @since 3.16.0
*/
insertTextMode?: InsertTextMode | undefined;
/**
* An {@link TextEdit edit} which is applied to a document when selecting
* this completion. When an edit is provided the value of
* {@link CompletionItem.insertText insertText} is ignored.
*
* Most editors support two different operations when accepting a completion
* item. One is to insert a completion text and the other is to replace an
* existing text with a completion text. Since this can usually not be
* predetermined by a server it can report both ranges. Clients need to
* signal support for `InsertReplaceEdits` via the
* `textDocument.completion.insertReplaceSupport` client capability
* property.
*
* *Note 1:* The text edit's range as well as both ranges from an insert
* replace edit must be a [single line] and they must contain the position
* at which completion has been requested.
* *Note 2:* If an `InsertReplaceEdit` is returned the edit's insert range
* must be a prefix of the edit's replace range, that means it must be
* contained and starting at the same position.
*
* @since 3.16.0 additional type `InsertReplaceEdit`
*/
textEdit?: TextEdit | InsertReplaceEdit | undefined;
/**
* The edit text used if the completion item is part of a CompletionList and
* CompletionList defines an item default for the text edit range.
*
* Clients will only honor this property if they opt into completion list
* item defaults using the capability `completionList.itemDefaults`.
*
* If not provided and a list's default range is provided the label
* property is used as a text.
*
* @since 3.17.0
*/
textEditText?: string | undefined;
/**
* An optional array of additional {@link TextEdit text edits} that are applied when
* selecting this completion. Edits must not overlap (including the same insert position)
* with the main {@link CompletionItem.textEdit edit} nor with themselves.
*
* Additional text edits should be used to change text unrelated to the current cursor position
* (for example adding an import statement at the top of the file if the completion item will
* insert an unqualified type).
*/
additionalTextEdits?: TextEdit[] | undefined;
/**
* An optional set of characters that when pressed while this completion is active will accept it first and
* then type that character. *Note* that all commit characters should have `length=1` and that superfluous
* characters will be ignored.
*/
commitCharacters?: string[] | undefined;
/**
* An optional {@link Command command} that is executed *after* inserting this completion. *Note* that
* additional modifications to the current document should be described with the
* {@link CompletionItem.additionalTextEdits additionalTextEdits}-property.
*/
command?: Command | undefined;
/**
* A data entry field that is preserved on a completion item between a
* {@link CompletionRequest} and a {@link CompletionResolveRequest}.
*/
data?: LSPAny | undefined;
}
/**
* Specifies how fields from a completion item should be combined with those
* from `completionList.itemDefaults`.
*
* If unspecified, all fields will be treated as ApplyKind.Replace.
*
* If a field's value is ApplyKind.Replace, the value from a completion item (if
* provided and not `null`) will always be used instead of the value from
* `completionItem.itemDefaults`.
*
* If a field's value is ApplyKind.Merge, the values will be merged using the rules
* defined against each field below.
*
* Servers are only allowed to return `applyKind` if the client
* signals support for this via the `completionList.applyKindSupport`
* capability.
*
* @since 3.18.0
*/
export interface CompletionItemApplyKinds {
/**
* Specifies whether commitCharacters on a completion will replace or be
* merged with those in `completionList.itemDefaults.commitCharacters`.
*
* If ApplyKind.Replace, the commit characters from the completion item will
* always be used unless not provided, in which case those from
* `completionList.itemDefaults.commitCharacters` will be used. An
* empty list can be used if a completion item does not have any commit
* characters and also should not use those from
* `completionList.itemDefaults.commitCharacters`.
*
* If ApplyKind.Merge the commitCharacters for the completion will be the
* union of all values in both `completionList.itemDefaults.commitCharacters`
* and the completion's own `commitCharacters`.
*
* @since 3.18.0
*/
commitCharacters?: ApplyKind | undefined;
/**
* Specifies whether the `data` field on a completion will replace or
* be merged with data from `completionList.itemDefaults.data`.
*
* If ApplyKind.Replace, the data from the completion item will be used if
* provided (and not `null`), otherwise
* `completionList.itemDefaults.data` will be used. An empty object can
* be used if a completion item does not have any data but also should
* not use the value from `completionList.itemDefaults.data`.
*
* If ApplyKind.Merge, a shallow merge will be performed between
* `completionList.itemDefaults.data` and the completion's own data
* using the following rules:
*
* - If a completion's `data` field is not provided (or `null`), the
* entire `data` field from `completionList.itemDefaults.data` will be
* used as-is.
* - If a completion's `data` field is provided, each field will
* overwrite the field of the same name in
* `completionList.itemDefaults.data` but no merging of nested fields
* within that value will occur.
*
* @since 3.18.0
*/
data?: ApplyKind | undefined;
}
/**
* In many cases the items of an actual completion result share the same
* value for properties like `commitCharacters` or the range of a text
* edit. A completion list can therefore define item defaults which will
* be used if a completion item itself doesn't specify the value.
*
* If a completion list specifies a default value and a completion item
* also specifies a corresponding value, the rules for combining these are
* defined by `applyKinds` (if the client supports it), defaulting to
* ApplyKind.Replace.
*
* Servers are only allowed to return default values if the client
* signals support for this via the `completionList.itemDefaults`
* capability.
*
* @since 3.17.0
*/
export interface CompletionItemDefaults {
/**
* A default commit character set.
*
* @since 3.17.0
*/
commitCharacters?: string[] | undefined;
/**
* A default edit range.
*
* @since 3.17.0
*/
editRange?: Range | EditRangeWithInsertReplace | undefined;
/**
* A default insert text format.
*
* @since 3.17.0
*/
insertTextFormat?: InsertTextFormat | undefined;
/**
* A default insert text mode.
*
* @since 3.17.0
*/
insertTextMode?: InsertTextMode | undefined;
/**
* A default data value.
*
* @since 3.17.0
*/
data?: LSPAny | undefined;
}
/**
* The kind of a completion entry.
*/
export type CompletionItemKind = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25;
/**
* Additional details for a completion item label.
*
* @since 3.17.0
*/
export interface CompletionItemLabelDetails {
/**
* An optional string which is rendered less prominently directly after {@link CompletionItem.label label},
* without any spacing. Should be used for function signatures and type annotations.
*/
detail?: string | undefined;
/**
* An optional string which is rendered less prominently after {@link CompletionItem.detail}. Should be used
* for fully qualified names and file paths.
*/
description?: string | undefined;
}
/**
* Completion item tags are extra annotations that tweak the rendering of a completion
* item.
*
* @since 3.15.0
*/
export type CompletionItemTag = 1;
/**
* Represents a collection of {@link CompletionItem completion items} to be presented
* in the editor.
*/
export interface CompletionList {
/**
* This list it not complete. Further typing results in recomputing this list.
*
* Recomputed lists have all their items replaced (not appended) in the
* incomplete completion sessions.
*/
isIncomplete: boolean;
/**
* In many cases the items of an actual completion result share the same
* value for properties like `commitCharacters` or the range of a text
* edit. A completion list can therefore define item defaults which will
* be used if a completion item itself doesn't specify the value.
*
* If a completion list specifies a default value and a completion item
* also specifies a corresponding value, the rules for combining these are
* defined by `applyKinds` (if the client supports it), defaulting to
* ApplyKind.Replace.
*
* Servers are only allowed to return default values if the client
* signals support for this via the `completionList.itemDefaults`
* capability.
*
* @since 3.17.0
*/
itemDefaults?: CompletionItemDefaults | undefined;
/**
* Specifies how fields from a completion item should be combined with those
* from `completionList.itemDefaults`.
*
* If unspecified, all fields will be treated as ApplyKind.Replace.
*
* If a field's value is ApplyKind.Replace, the value from a completion item
* (if provided and not `null`) will always be used instead of the value
* from `completionItem.itemDefaults`.
*
* If a field's value is ApplyKind.Merge, the values will be merged using
* the rules defined against each field below.
*
* Servers are only allowed to return `applyKind` if the client
* signals support for this via the `completionList.applyKindSupport`
* capability.
*
* @since 3.18.0
*/
applyKind?: CompletionItemApplyKinds | undefined;
/**
* The completion items.
*/
items: CompletionItem[];
}
/**
* Completion parameters
*/
export interface CompletionParams {
/**
* The text document.
*/
textDocument: TextDocumentIdentifier;
/**
* The position inside the text document.
*/
position: Position;
/**
* An optional token that a server can use to report work done progress.
*/
workDoneToken?: ProgressToken | undefined;
/**
* An optional token that a server can use to report partial results (e.g. streaming) to
* the client.
*/
partialResultToken?: ProgressToken | undefined;
/**
* The completion context. This is only available it the client specifies
* to send this using the client capability `textDocument.completion.contextSupport === true`
*/
context?: CompletionContext | undefined;
}
/**
* How a completion was triggered
*/
export type CompletionTriggerKind = 1 | 2 | 3;
/**
* Create file operation.
*/
export interface CreateFile {
/**
* A create
*/
kind: "create";
/**
* An optional annotation identifier describing the operation.
*
* @since 3.16.0
*/
annotationId?: ChangeAnnotationIdentifier | undefined;
/**
* The resource to create.
*/
uri: DocumentUri;
/**
* Additional options
*/
options?: CreateFileOptions | undefined;
}
/**
* Options to create a file.
*/
export interface CreateFileOptions {
/**
* Overwrite existing file. Overwrite wins over `ignoreIfExists`
*/
overwrite?: boolean | undefined;
/**
* Ignore if exists.
*/
ignoreIfExists?: boolean | undefined;
}
/**
* The definition of a symbol represented as one or many {@link Location locations}.
* For most programming languages there is only one location at which a symbol is
* defined.
*
* Servers should prefer returning `DefinitionLink` over `Definition` if supported
* by the client.
*/
export type Definition = Location | Location[];
/**
* Information about where a symbol is defined.
*
* Provides additional metadata over normal {@link Location location} definitions, including the range of
* the defining symbol
*/
export type DefinitionLink = LocationLink;
/**
* Parameters for a {@link DefinitionRequest}.
*/
export interface DefinitionParams {
/**
* The text document.
*/
textDocument: TextDocumentIdentifier;
/**
* The position inside the text document.
*/
position: Position;
/**
* An optional token that a server can use to report work done progress.
*/
workDoneToken?: ProgressToken | undefined;
/**
* An optional token that a server can use to report partial results (e.g. streaming) to
* the client.
*/
partialResultToken?: ProgressToken | undefined;
}
/**
* Delete file operation
*/
export interface DeleteFile {
/**
* A delete
*/
kind: "delete";
/**
* An optional annotation identifier describing the operation.
*
* @since 3.16.0
*/
annotationId?: ChangeAnnotationIdentifier | undefined;
/**
* The file to delete.
*/
uri: DocumentUri;
/**
* Delete options.
*/
options?: DeleteFileOptions | undefined;
}
/**
* Delete file options
*/
export interface DeleteFileOptions {
/**
* Delete the content recursively if a folder is denoted.
*/
recursive?: boolean | undefined;
/**
* Ignore the operation if the file doesn't exist.
*/
ignoreIfNotExists?: boolean | undefined;
}
/**
* Represents a diagnostic, such as a compiler error or warning. Diagnostic objects
* are only valid in the scope of a resource.
*/
export interface Diagnostic {
/**
* The range at which the message applies
*/
range: Range;
/**
* The diagnostic's severity. To avoid interpretation mismatches when a
* server is used with different clients it is highly recommended that servers
* always provide a severity value.
*/
severity?: DiagnosticSeverity | undefined;
/**
* The diagnostic's code, which usually appear in the user interface.
*/
code?: number | string | undefined;
/**
* An optional property to describe the error code.
* Requires the code field (above) to be present/not null.
*
* @since 3.16.0
*/
codeDescription?: CodeDescription | undefined;
/**
* A human-readable string describing the source of this
* diagnostic, e.g. 'typescript' or 'super lint'. It usually
* appears in the user interface.
*/
source?: string | undefined;
/**
* The diagnostic's message. It usually appears in the user interface.
*
* @since 3.18.0 - support for MarkupContent. This is guarded by the client
* capability `textDocument.diagnostic.markupMessageSupport`.
*/
message: string | MarkupContent;
/**
* Additional metadata about the diagnostic.
*
* @since 3.15.0
*/
tags?: DiagnosticTag[] | undefined;
/**
* An array of related diagnostic information, e.g. when symbol-names within
* a scope collide all definitions can be marked via this property.
*/
relatedInformation?: DiagnosticRelatedInformation[] | undefined;
/**
* A data entry field that is preserved between a `textDocument/publishDiagnostics`
* notification and `textDocument/codeAction` request.
*
* @since 3.16.0
*/
data?: LSPAny | undefined;
}
/**
* Represents a related message and source code location for a diagnostic. This should be
* used to point to code locations that cause or related to a diagnostics, e.g when duplicating
* a symbol in a scope.
*/
export interface DiagnosticRelatedInformation {
/**
* The location of this related diagnostic information.
*/
location: Location;
/**
* The message of this related diagnostic information.
*/
message: string;
}
/**
* The diagnostic's severity.
*/
export type DiagnosticSeverity = 1 | 2 | 3 | 4;
/**
* The diagnostic tags.
*
* @since 3.15.0
*/
export type DiagnosticTag = 1 | 2;
/**
* Parameters of the document diagnostic request.
*
* @since 3.17.0
*/
export interface DocumentDiagnosticParams {
/**
* An optional token that a server can use to report work done progress.
*/
workDoneToken?: ProgressToken | undefined;
/**
* An optional token that a server can use to report partial results (e.g. streaming) to
* the client.
*/
partialResultToken?: ProgressToken | undefined;
/**
* The text document.
*/
textDocument: TextDocumentIdentifier;
/**
* The additional identifier provided during registration.
*/
identifier?: string | undefined;
/**
* The result id of a previous response if provided.
*/
previousResultId?: string | undefined;
}
/**
* The result of a document diagnostic pull request. A report can
* either be a full report containing all diagnostics for the
* requested document or an unchanged report indicating that nothing
* has changed in terms of diagnostics in comparison to the last
* pull request.
*
* @since 3.17.0
*/
export type DocumentDiagnosticReport = RelatedFullDocumentDiagnosticReport | RelatedUnchangedDocumentDiagnosticReport;
/**
* The parameters of a {@link DocumentFormattingRequest}.
*/
export interface DocumentFormattingParams {
/**
* An optional token that a server can use to report work done progress.
*/
workDoneToken?: ProgressToken | undefined;
/**
* The document to format.
*/
textDocument: TextDocumentIdentifier;
/**
* The format options.
*/
options: FormattingOptions;
}
/**
* A document highlight is a range inside a text document which deserves
* special attention. Usually a document highlight is visualized by changing
* the background color of its range.
*/
export interface DocumentHighlight {
/**
* The range this highlight applies to.
*/
range: Range;
/**
* The highlight kind, default is {@link DocumentHighlightKind.Text text}.
*/
kind?: DocumentHighlightKind | undefined;
}
/**
* A document highlight kind.
*/
export type DocumentHighlightKind = 1 | 2 | 3;
/**
* Parameters for a {@link DocumentHighlightRequest}.
*/
export interface DocumentHighlightParams {
/**
* The text document.
*/
textDocument: TextDocumentIdentifier;
/**
* The position inside the text document.
*/
position: Position;
/**
* An optional token that a server can use to report work done progress.
*/
workDoneToken?: ProgressToken | undefined;
/**
* An optional token that a server can use to report partial results (e.g. streaming) to
* the client.
*/
partialResultToken?: ProgressToken | undefined;
}
/**
* The parameters of a {@link DocumentOnTypeFormattingRequest}.
*/
export interface DocumentOnTypeFormattingParams {
/**
* The document to format.
*/
textDocument: TextDocumentIdentifier;
/**
* The position around which the on type formatting should happen.
* This is not necessarily the exact position where the character denoted
* by the property `ch` got typed.
*/
position: Position;
/**
* The character that has been typed that triggered the formatting
* on type request. That is not necessarily the last character that
* got inserted into the document since the client could auto insert
* characters as well (e.g. like automatic brace completion).
*/
ch: string;
/**
* The formatting options.
*/
options: FormattingOptions;
}
/**
* The parameters of a {@link DocumentRangeFormattingRequest}.
*/
export interface DocumentRangeFormattingParams {
/**
* An optional token that a server can use to report work done progress.
*/
workDoneToken?: ProgressToken | undefined;
/**
* The document to format.
*/
textDocument: TextDocumentIdentifier;
/**
* The range to format
*/
range: Range;
/**
* The format options
*/
options: FormattingOptions;
}
/**
* Represents programming constructs like variables, classes, interfaces etc.
* that appear in a document. Document symbols can be hierarchical and they
* have two ranges: one that encloses its definition and one that points to
* its most interesting range, e.g. the range of an identifier.
*/
export interface DocumentSymbol {
/**
* The name of this symbol. Will be displayed in the user interface and therefore must not be
* an empty string or a string only consisting of white spaces.
*/
name: string;
/**
* More detail for this symbol, e.g the signature of a function.
*/
detail?: string | undefined;
/**
* The kind of this symbol.
*/
kind: SymbolKind;
/**
* Tags for this document symbol.
*
* @since 3.16.0
*/
tags?: SymbolTag[] | undefined;
/**
* Indicates if this symbol is deprecated.
*
* @deprecated Use tags instead
*/
deprecated?: boolean | undefined;
/**
* The range enclosing this symbol not including leading/trailing whitespace but everything else
* like comments. This information is typically used to determine if the clients cursor is
* inside the symbol to reveal in the symbol in the UI.
*/
range: Range;
/**
* The range that should be selected and revealed when this symbol is being picked, e.g the name of a function.
* Must be contained by the `range`.
*/
selectionRange: Range;
/**
* Children of this symbol, e.g. properties of a class.
*/
children?: DocumentSymbol[] | undefined;
}
/**
* Parameters for a {@link DocumentSymbolRequest}.
*/
export interface DocumentSymbolParams {
/**
* An optional token that a server can use to report work done progress.
*/
workDoneToken?: ProgressToken | undefined;
/**
* An optional token that a server can use to report partial results (e.g. streaming) to
* the client.
*/
partialResultToken?: ProgressToken | undefined;
/**
* The text document.
*/
textDocument: TextDocumentIdentifier;
}
export type DocumentUri = string;
/**
* Edit range variant that includes ranges for insert and replace operations.
*
* @since 3.18.0
*/
export interface EditRangeWithInsertReplace {
insert: Range;
replace: Range;
}
/**
* Represents a folding range. To be valid, start and end line must be bigger than zero and smaller
* than the number of lines in the document. Clients are free to ignore invalid ranges.
*/
export interface FoldingRange {
/**
* The zero-based start line of the range to fold. The folded area starts after the line's last character.
* To be valid, the end must be zero or larger and smaller than the number of lines in the document.
*/
startLine: number;
/**
* The zero-based character offset from where the folded range starts. If not defined, defaults to the length of the start line.
*/
startCharacter?: number | undefined;
/**
* The zero-based end line of the range to fold. The folded area ends with the line's last character.
* To be valid, the end must be zero or larger and smaller than the number of lines in the document.
*/
endLine: number;
/**
* The zero-based character offset before the folded range ends. If not defined, defaults to the length of the end line.
*/
endCharacter?: number | undefined;
/**
* Describes the kind of the folding range such as 'comment' or 'region'. The kind
* is used to categorize folding ranges and used by commands like 'Fold all comments'.
* See {@link FoldingRangeKind} for an enumeration of standardized kinds.
*/
kind?: FoldingRangeKind | undefined;
/**
* The text that the client should show when the specified range is
* collapsed. If not defined or not supported by the client, a default
* will be chosen by the client.
*
* @since 3.17.0
*/
collapsedText?: string | undefined;
}
/**
* A set of predefined range kinds.
*/
export type FoldingRangeKind = "comment" | "imports" | "region" | string;
/**
* Parameters for a {@link FoldingRangeRequest}.
*/
export interface FoldingRangeParams {
/**
* An optional token that a server can use to report work done progress.
*/
workDoneToken?: ProgressToken | undefined;
/**
* An optional token that a server can use to report partial results (e.g. streaming) to
* the client.
*/
partialResultToken?: ProgressToken | undefined;
/**
* The text document.
*/
textDocument: TextDocumentIdentifier;
}
/**
* Value-object describing what options formatting should use.
*/
export interface FormattingOptions {
/**
* Size of a tab in spaces.
*/
tabSize: number;
/**
* Prefer spaces over tabs.
*/
insertSpaces: boolean;
/**
* Trim trailing whitespace on a line.
*
* @since 3.15.0
*/
trimTrailingWhitespace?: boolean | undefined;
/**
* Insert a newline character at the end of the file if one does not exist.
*
* @since 3.15.0
*/
insertFinalNewline?: boolean | undefined;
/**
* Trim all newlines after the final newline at the end of the file.
*
* @since 3.15.0
*/
trimFinalNewlines?: boolean | undefined;
[key: string]: boolean | number | string | undefined;
}
/**
* A diagnostic report with a full set of problems.
*
* @since 3.17.0
*/
export interface FullDocumentDiagnosticReport {
/**
* A full document diagnostic report.
*/
kind: "full";
/**
* An optional result id. If provided it will
* be sent on the next diagnostic request for the
* same document.
*/
resultId?: string | undefined;
/**
* The actual items.
*/
items: Diagnostic[];
}
/**
* The result of a hover request.
*/
export interface Hover {
/**
* The hover's content
*/
contents: MarkupContent | MarkedString | MarkedString[];
/**
* An optional range inside the text document that is used to
* visualize the hover, e.g. by changing the background color.
*/
range?: Range | undefined;
/**
* Whether the verbosity level can be increased for this hover.
*/
canIncreaseVerbosity?: boolean | undefined;
/**
* VS-specific rich content (symbol icon + colorized/classified text) rendered by clients that support Visual Studio extensions, in place of `contents`.
*/
_vs_rawContent?: VSContainerElement | undefined;
}
/**
* Parameters for a {@link HoverRequest}.
*/
export interface HoverParams {
/**
* The text document.
*/
textDocument: TextDocumentIdentifier;
/**
* The position inside the text document.
*/
position: Position;
/**
* An optional token that a server can use to report work done progress.
*/
workDoneToken?: ProgressToken | undefined;
/**
* Controls how many levels of type definitions will be expanded. Default is 0.
*/
verbosityLevel?: number | undefined;
}
export interface ImplementationParams {
/**
* The text document.
*/
textDocument: TextDocumentIdentifier;
/**
* The position inside the text document.
*/
position: Position;
/**
* An optional token that a server can use to report work done progress.
*/
workDoneToken?: ProgressToken | undefined;
/**
* An optional token that a server can use to report partial results (e.g. streaming) to
* the client.
*/
partialResultToken?: ProgressToken | undefined;
}
/**
* Inlay hint information.
*
* @since 3.17.0
*/
export interface InlayHint {
/**
* The position of this hint.
*
* If multiple hints have the same position, they will be shown in the order
* they appear in the response.
*/
position: Position;
/**
* The label of this hint. A human readable string or an array of
* InlayHintLabelPart label parts.
*
* *Note* that neither the string nor the label part can be empty.
*/
label: string | InlayHintLabelPart[];
/**
* The kind of this hint. Can be omitted in which case the client
* should fall back to a reasonable default.
*/
kind?: InlayHintKind | undefined;
/**
* Optional text edits that are performed when accepting this inlay hint.
*
* *Note* that edits are expected to change the document so that the inlay
* hint (or its nearest variant) is now part of the document and the inlay
* hint itself is now obsolete.
*/
textEdits?: TextEdit[] | undefined;
/**
* The tooltip text when you hover over this item.
*/
tooltip?: string | MarkupContent | undefined;
/**
* Render padding before the hint.
*
* Note: Padding should use the editor's background color, not the
* background color of the hint itself. That means padding can be used
* to visually align/separate an inlay hint.
*/
paddingLeft?: boolean | undefined;
/**
* Render padding after the hint.
*
* Note: Padding should use the editor's background color, not the
* background color of the hint itself. That means padding can be used
* to visually align/separate an inlay hint.
*/
paddingRight?: boolean | undefined;
/**
* A data entry field that is preserved on an inlay hint between
* a `textDocument/inlayHint` and a `inlayHint/resolve` request.
*/
data?: LSPAny | undefined;
}
/**
* Inlay hint kinds.
*
* @since 3.17.0
*/
export type InlayHintKind = 1 | 2;
/**
* An inlay hint label part allows for interactive and composite labels
* of inlay hints.
*
* @since 3.17.0
*/
export interface InlayHintLabelPart {
/**
* The value of this label part.
*/
value: string;
/**
* The tooltip text when you hover over this label part. Depending on
* the client capability `inlayHint.resolveSupport` clients might resolve
* this property late using the resolve request.
*/
tooltip?: string | MarkupContent | undefined;
/**
* An optional source code location that represents this
* label part.
*
* The editor will use this location for the hover and for code navigation
* features: This part will become a clickable link that resolves to the
* definition of the symbol at the given location (not necessarily the
* location itself), it shows the hover that shows at the given location,
* and it shows a context menu with further code navigation commands.
*
* Depending on the client capability `inlayHint.resolveSupport` clients
* might resolve this property late using the resolve request.
*/
location?: Location | undefined;
/**
* An optional command for this label part.
*
* Depending on the client capability `inlayHint.resolveSupport` clients
* might resolve this property late using the resolve request.
*/
command?: Command | undefined;
}
/**
* A parameter literal used in inlay hint requests.
*
* @since 3.17.0
*/
export interface InlayHintParams {
/**
* An optional token that a server can use to report work done progress.
*/
workDoneToken?: ProgressToken | undefined;
/**
* The text document.
*/
textDocument: TextDocumentIdentifier;
/**
* The document range for which inlay hints should be computed.
*/
range: Range;
}
/**
* A special text edit to provide an insert and a replace operation.
*
* @since 3.16.0
*/
export interface InsertReplaceEdit {
/**
* The string to be inserted.
*/
newText: string;
/**
* The range if the insert is requested
*/
insert: Range;
/**
* The range if the replace is requested.
*/
replace: Range;
}
/**
* Defines whether the insert text in a completion item should be interpreted as
* plain text or a snippet.
*/
export type InsertTextFormat = 1 | 2;
/**
* How whitespace and indentation is handled during completion
* item insertion.
*
* @since 3.16.0
*/
export type InsertTextMode = 1 | 2;
/**
* The LSP any type.
* Please note that strictly speaking a property with the value `undefined`
* can't be converted into JSON preserving the property name. However for
* convenience it is allowed and assumed that all these properties are
* optional as well.
* @since 3.17.0
*/
export type LSPAny = LSPObject | LSPArray | string | number | boolean | null;
/**
* LSP arrays.
* @since 3.17.0
*/
export type LSPArray = LSPAny[];
/**
* LSP object definition.
* @since 3.17.0
*/
export type LSPObject = {
[key: string]: LSPAny;
};
export interface LinkedEditingRangeParams {
/**
* The text document.
*/
textDocument: TextDocumentIdentifier;
/**
* The position inside the text document.
*/
position: Position;
/**
* An optional token that a server can use to report work done progress.
*/
workDoneToken?: ProgressToken | undefined;
}
/**
* The result of a linked editing range request.
*
* @since 3.16.0
*/
export interface LinkedEditingRanges {
/**
* A list of ranges that can be edited together. The ranges must have
* identical length and contain identical text content. The ranges cannot overlap.
*/
ranges: Range[];
/**
* An optional word pattern (regular expression) that describes valid contents for
* the given ranges. If no pattern is provided, the client configuration's word
* pattern will be used.
*/
wordPattern?: string | undefined;
}
/**
* Represents a location inside a resource, such as a line
* inside a text file.
*/
export interface Location {
uri: DocumentUri;
range: Range;
}
/**
* Represents the connection of two locations. Provides additional metadata over normal {@link Location locations},
* including an origin range.
*/
export interface LocationLink {
/**
* Span of the origin of this link.
*
* Used as the underlined span for mouse interaction. Defaults to the word range at
* the definition position.
*/
originSelectionRange?: Range | undefined;
/**
* The target resource identifier of this link.
*/
targetUri: DocumentUri;
/**
* The full target range of this link. If the target for example is a symbol then target range is the
* range enclosing this symbol not including leading/trailing whitespace but everything else
* like comments. This information is typically used to highlight the range in the editor.
*/
targetRange: Range;
/**
* The range that should be selected and revealed when this link is being followed, e.g the name of a function.
* Must be contained by the `targetRange`. See also `DocumentSymbol#range`
*/
targetSelectionRange: Range;
}
/**
* Location with only uri and does not include range.
*
* @since 3.18.0
*/
export interface LocationUriOnly {
uri: DocumentUri;
}
/**
* MarkedString can be used to render human readable text. It is either a markdown string
* or a code-block that provides a language and a code snippet. The language identifier
* is semantically equal to the optional language identifier in fenced code blocks in GitHub
* issues. See https://help.github.com/articles/creating-and-highlighting-code-blocks/#syntax-highlighting
*
* The pair of a language and a value is an equivalent to markdown:
* ```${language}
* ${value}
* ```
*
* Note that markdown strings will be sanitized - that means html will be escaped.
* @deprecated use MarkupContent instead.
*/
export type MarkedString = string | MarkedStringWithLanguage;
/**
* @since 3.18.0
* @deprecated use MarkupContent instead.
*/
export interface MarkedStringWithLanguage {
language: string;
value: string;
}
/**
* A `MarkupContent` literal represents a string value which content is interpreted base on its
* kind flag. Currently the protocol supports `plaintext` and `markdown` as markup kinds.
*
* If the kind is `markdown` then the value can contain fenced code blocks like in GitHub issues.
* See https://help.github.com/articles/creating-and-highlighting-code-blocks/#syntax-highlighting
*
* Here is an example how such a string can be constructed using JavaScript / TypeScript:
* ```ts
* let markdown: MarkdownContent = {
* kind: MarkupKind.Markdown,
* value: [
* '# Header',
* 'Some text',
* '```typescript',
* 'someCode();',
* '```'
* ].join('\n')
* };
* ```
*
* *Please Note* that clients might sanitize the return markdown. A client could decide to
* remove HTML from the markdown to avoid script execution.
*/
export interface MarkupContent {
/**
* The type of the Markup
*/
kind: MarkupKind;
/**
* The content itself
*/
value: string;
}
/**
* Describes the content type that a client supports in various
* result literals like `Hover`, `ParameterInfo` or `CompletionItem`.
*
* Please note that `MarkupKinds` must not start with a `$`. This kinds
* are reserved for internal usage.
*/
export type MarkupKind = "plaintext" | "markdown";
/**
* Represents a collection of document highlights from a single document, used in multi-document highlight responses.
*/
export interface MultiDocumentHighlight {
/**
* The URI of the document containing the highlights.
*/
uri: DocumentUri;
/**
* The highlights for the document.
*/
highlights: DocumentHighlight[];
}
/**
* Parameters for the custom/textDocument/multiDocumentHighlight request.
*/
export interface MultiDocumentHighlightParams {
/**
* The text document.
*/
textDocument: TextDocumentIdentifier;
/**
* The position inside the text document.
*/
position: Position;
/**
* The list of file URIs to search for highlights across.
*/
filesToSearch: DocumentUri[];
}
/**
* A text document identifier to optionally denote a specific version of a text document.
*/
export interface OptionalVersionedTextDocumentIdentifier {
/**
* The text document's uri.
*/
uri: DocumentUri;
/**
* The version number of this document. If a versioned text document identifier
* is sent from the server to the client and the file is not open in the editor
* (the server has not received an open notification before) the server can send
* `null` to indicate that the version is unknown and the content on disk is the
* truth (as specified with document content ownership).
*/
version: number | null;
}
/**
* Represents a parameter of a callable-signature. A parameter can
* have a label and a doc-comment.
*/
export interface ParameterInformation {
/**
* The label of this parameter information.
*
* Either a string or an inclusive start and exclusive end offsets within its containing
* signature label. (see SignatureInformation.label). The offsets are based on a UTF-16
* string representation as `Position` and `Range` does.
*
* To avoid ambiguities a server should use the [start, end] offset value instead of using
* a substring. Whether a client support this is controlled via `labelOffsetSupport` client
* capability.
*
* *Note*: a label of type string should be a substring of its containing signature label.
* Its intended use case is to highlight the parameter label part in the `SignatureInformation.label`.
*/
label: string | [number, number];
/**
* The human-readable doc-comment of this parameter. Will be shown
* in the UI but can be omitted.
*/
documentation?: string | MarkupContent | undefined;
}
/**
* Position in a text document expressed as zero-based line and character
* offset. Prior to 3.17 the offsets were always based on a UTF-16 string
* representation. So a string of the form `a𐐀b` the character offset of the
* character `a` is 0, the character offset of `𐐀` is 1 and the character
* offset of b is 3 since `𐐀` is represented using two code units in UTF-16.
* Since 3.17 clients and servers can agree on a different string encoding
* representation (e.g. UTF-8). The client announces it's supported encoding
* via the client capability [`general.positionEncodings`](https://microsoft.github.io/language-server-protocol/specifications/specification-current/#clientCapabilities).
* The value is an array of position encodings the client supports, with
* decreasing preference (e.g. the encoding at index `0` is the most preferred
* one). To stay backwards compatible the only mandatory encoding is UTF-16
* represented via the string `utf-16`. The server can pick one of the
* encodings offered by the client and signals that encoding back to the
* client via the initialize result's property
* [`capabilities.positionEncoding`](https://microsoft.github.io/language-server-protocol/specifications/specification-current/#serverCapabilities). If the string value
* `utf-16` is missing from the client's capability `general.positionEncodings`
* servers can safely assume that the client supports UTF-16. If the server
* omits the position encoding in its initialize result the encoding defaults
* to the string value `utf-16`. Implementation considerations: since the
* conversion from one encoding into another requires the content of the
* file / line the conversion is best done where the file is read which is
* usually on the server side.
*
* Positions are line end character agnostic. So you can not specify a position
* that denotes `\r|\n` or `\n|` where `|` represents the character offset.
*
* @since 3.17.0 - support for negotiated position encoding.
*/
export interface Position {
/**
* Line position in a document (zero-based).
*/
line: number;
/**
* Character offset on a line in a document (zero-based).
*
* The meaning of this offset is determined by the negotiated
* `PositionEncodingKind`.
*/
character: number;
}
/**
* @since 3.18.0
*/
export interface PrepareRenameDefaultBehavior {
defaultBehavior: boolean;
}
export interface PrepareRenameParams {
/**
* The text document.
*/
textDocument: TextDocumentIdentifier;
/**
* The position inside the text document.
*/
position: Position;
/**
* An optional token that a server can use to report work done progress.
*/
workDoneToken?: ProgressToken | undefined;
}
/**
* @since 3.18.0
*/
export interface PrepareRenamePlaceholder {
range: Range;
placeholder: string;
}
export type PrepareRenameResult = Range | PrepareRenamePlaceholder | PrepareRenameDefaultBehavior;
export type ProgressToken = number | string;
/**
* A range in a text document expressed as (zero-based) start and end positions.
*
* If you want to specify a range that contains a line including the line ending
* character(s) then use an end position denoting the start of the next line.
* For example:
* ```ts
* {
* start: { line: 5, character: 23 }
* end : { line 6, character : 0 }
* }
* ```
*/
export interface Range {
/**
* The range's start position.
*/
start: Position;
/**
* The range's end position.
*/
end: Position;
}
/**
* Value-object that contains additional information when
* requesting references.
*/
export interface ReferenceContext {
/**
* Include the declaration of the current symbol.
*/
includeDeclaration: boolean;
}
/**
* Parameters for a {@link ReferencesRequest}.
*/
export interface ReferenceParams {
/**
* The text document.
*/
textDocument: TextDocumentIdentifier;
/**
* The position inside the text document.
*/
position: Position;
/**
* An optional token that a server can use to report work done progress.
*/
workDoneToken?: ProgressToken | undefined;
/**
* An optional token that a server can use to report partial results (e.g. streaming) to
* the client.
*/
partialResultToken?: ProgressToken | undefined;
context: ReferenceContext;
}
/**
* A full diagnostic report with a set of related documents.
*
* @since 3.17.0
*/
export interface RelatedFullDocumentDiagnosticReport {
/**
* A full document diagnostic report.
*/
kind: "full";
/**
* An optional result id. If provided it will
* be sent on the next diagnostic request for the
* same document.
*/
resultId?: string | undefined;
/**
* The actual items.
*/
items: Diagnostic[];
/**
* Diagnostics of related documents. This information is useful
* in programming languages where code in a file A can generate
* diagnostics in a file B which A depends on. An example of
* such a language is C/C++ where marco definitions in a file
* a.cpp and result in errors in a header file b.hpp.
*
* @since 3.17.0
*/
relatedDocuments?: {
[key: DocumentUri]: FullDocumentDiagnosticReport | UnchangedDocumentDiagnosticReport;
} | undefined;
}
/**
* An unchanged diagnostic report with a set of related documents.
*
* @since 3.17.0
*/
export interface RelatedUnchangedDocumentDiagnosticReport {
/**
* A document diagnostic report indicating
* no changes to the last result. A server can
* only return `unchanged` if result ids are
* provided.
*/
kind: "unchanged";
/**
* A result id which will be sent on the next
* diagnostic request for the same document.
*/
resultId: string;
/**
* Diagnostics of related documents. This information is useful
* in programming languages where code in a file A can generate
* diagnostics in a file B which A depends on. An example of
* such a language is C/C++ where marco definitions in a file
* a.cpp and result in errors in a header file b.hpp.
*
* @since 3.17.0
*/
relatedDocuments?: {
[key: DocumentUri]: FullDocumentDiagnosticReport | UnchangedDocumentDiagnosticReport;
} | undefined;
}
/**
* Rename file operation
*/
export interface RenameFile {
/**
* A rename
*/
kind: "rename";
/**
* An optional annotation identifier describing the operation.
*
* @since 3.16.0
*/
annotationId?: ChangeAnnotationIdentifier | undefined;
/**
* The old (existing) location.
*/
oldUri: DocumentUri;
/**
* The new location.
*/
newUri: DocumentUri;
/**
* Rename options.
*/
options?: RenameFileOptions | undefined;
}
/**
* Rename file options
*/
export interface RenameFileOptions {
/**
* Overwrite target if existing. Overwrite wins over `ignoreIfExists`
*/
overwrite?: boolean | undefined;
/**
* Ignores if target exists.
*/
ignoreIfExists?: boolean | undefined;
}
/**
* The parameters of a {@link RenameRequest}.
*/
export interface RenameParams {
/**
* The text document.
*/
textDocument: TextDocumentIdentifier;
/**
* The position inside the text document.
*/
position: Position;
/**
* An optional token that a server can use to report work done progress.
*/
workDoneToken?: ProgressToken | undefined;
/**
* The new name of the symbol. If the given name is not valid the
* request must return a {@link ResponseError} with an
* appropriate message set.
*/
newName: string;
}
/**
* A selection range represents a part of a selection hierarchy. A selection range
* may have a parent selection range that contains it.
*/
export interface SelectionRange {
/**
* The {@link Range range} of this selection range.
*/
range: Range;
/**
* The parent selection range containing this range. Therefore `parent.range` must contain `this.range`.
*/
parent?: SelectionRange | undefined;
}
/**
* A parameter literal used in selection range requests.
*/
export interface SelectionRangeParams {
/**
* An optional token that a server can use to report work done progress.
*/
workDoneToken?: ProgressToken | undefined;
/**
* An optional token that a server can use to report partial results (e.g. streaming) to
* the client.
*/
partialResultToken?: ProgressToken | undefined;
/**
* The text document.
*/
textDocument: TextDocumentIdentifier;
/**
* The positions inside the text document.
*/
positions: Position[];
}
/**
* @since 3.16.0
*/
export interface SemanticTokens {
/**
* An optional result id. If provided and clients support delta updating
* the client will include the result id in the next semantic token request.
* A server can then instead of computing all semantic tokens again simply
* send a delta.
*/
resultId?: string | undefined;
/**
* The actual tokens.
*/
data: number[];
}
/**
* @since 3.16.0
*/
export interface SemanticTokensParams {
/**
* An optional token that a server can use to report work done progress.
*/
workDoneToken?: ProgressToken | undefined;
/**
* An optional token that a server can use to report partial results (e.g. streaming) to
* the client.
*/
partialResultToken?: ProgressToken | undefined;
/**
* The text document.
*/
textDocument: TextDocumentIdentifier;
}
/**
* @since 3.16.0
*/
export interface SemanticTokensRangeParams {
/**
* An optional token that a server can use to report work done progress.
*/
workDoneToken?: ProgressToken | undefined;
/**
* An optional token that a server can use to report partial results (e.g. streaming) to
* the client.
*/
partialResultToken?: ProgressToken | undefined;
/**
* The text document.
*/
textDocument: TextDocumentIdentifier;
/**
* The range the semantic tokens are requested for.
*/
range: Range;
}
/**
* Signature help represents the signature of something
* callable. There can be multiple signature but only one
* active and only one active parameter.
*/
export interface SignatureHelp {
/**
* One or more signatures.
*/
signatures: SignatureInformation[];
/**
* The active signature. If omitted or the value lies outside the
* range of `signatures` the value defaults to zero or is ignored if
* the `SignatureHelp` has no signatures.
*
* Whenever possible implementors should make an active decision about
* the active signature and shouldn't rely on a default value.
*
* In future version of the protocol this property might become
* mandatory to better express this.
*/
activeSignature?: number | undefined;
/**
* The active parameter of the active signature.
*
* If `null`, no parameter of the signature is active (for example a named
* argument that does not match any declared parameters). This is only valid
* if the client specifies the client capability
* `textDocument.signatureHelp.noActiveParameterSupport === true`
*
* If omitted or the value lies outside the range of
* `signatures[activeSignature].parameters` defaults to 0 if the active
* signature has parameters.
*
* If the active signature has no parameters it is ignored.
*
* In future version of the protocol this property might become
* mandatory (but still nullable) to better express the active parameter if
* the active signature does have any.
*
* Since version 3.16.0 the `SignatureInformation` itself provides a
* `activeParameter` property and it should be used instead of this one.
*/
activeParameter?: number | null | undefined;
}
/**
* Additional information about the context in which a signature help request was triggered.
*
* @since 3.15.0
*/
export interface SignatureHelpContext {
/**
* Action that caused signature help to be triggered.
*/
triggerKind: SignatureHelpTriggerKind;
/**
* Character that caused signature help to be triggered.
*
* This is undefined when `triggerKind !== SignatureHelpTriggerKind.TriggerCharacter`
*/
triggerCharacter?: string | undefined;
/**
* `true` if signature help was already showing when it was triggered.
*
* Retriggers occurs when the signature help is already active and can be caused by actions such as
* typing a trigger character, a cursor move, or document content changes.
*/
isRetrigger: boolean;
/**
* The currently active `SignatureHelp`.
*
* The `activeSignatureHelp` has its `SignatureHelp.activeSignature` field updated based on
* the user navigating through available signatures.
*/
activeSignatureHelp?: SignatureHelp | undefined;
}
/**
* Parameters for a {@link SignatureHelpRequest}.
*/
export interface SignatureHelpParams {
/**
* The text document.
*/
textDocument: TextDocumentIdentifier;
/**
* The position inside the text document.
*/
position: Position;
/**
* An optional token that a server can use to report work done progress.
*/
workDoneToken?: ProgressToken | undefined;
/**
* The signature help context. This is only available if the client specifies
* to send this using the client capability `textDocument.signatureHelp.contextSupport === true`
*
* @since 3.15.0
*/
context?: SignatureHelpContext | undefined;
}
/**
* How a signature help was triggered.
*
* @since 3.15.0
*/
export type SignatureHelpTriggerKind = 1 | 2 | 3;
/**
* Represents the signature of something callable. A signature
* can have a label, like a function-name, a doc-comment, and
* a set of parameters.
*/
export interface SignatureInformation {
/**
* The label of this signature. Will be shown in
* the UI.
*/
label: string;
/**
* The human-readable doc-comment of this signature. Will be shown
* in the UI but can be omitted.
*/
documentation?: string | MarkupContent | undefined;
/**
* The parameters of this signature.
*/
parameters?: ParameterInformation[] | undefined;
/**
* The index of the active parameter.
*
* If `null`, no parameter of the signature is active (for example a named
* argument that does not match any declared parameters). This is only valid
* if the client specifies the client capability
* `textDocument.signatureHelp.noActiveParameterSupport === true`
*
* If provided (or `null`), this is used in place of
* `SignatureHelp.activeParameter`.
*
* @since 3.16.0
*/
activeParameter?: number | null | undefined;
/**
* A colorized label for the signature, providing classified text runs for VS syntax coloring.
*/
_vs_colorizedLabel?: VSClassifiedTextElement | undefined;
}
/**
* An interactive text edit.
*
* @since 3.18.0
*/
export interface SnippetTextEdit {
/**
* The range of the text document to be manipulated.
*/
range: Range;
/**
* The snippet to be inserted.
*/
snippet: StringValue;
/**
* The actual identifier of the snippet edit.
*/
annotationId?: ChangeAnnotationIdentifier | undefined;
}
/**
* A string value used as a snippet is a template which allows to insert text
* and to control the editor cursor when insertion happens.
*
* A snippet can define tab stops and placeholders with `$1`, `$2`
* and `${3:foo}`. `$0` defines the final tab stop, it defaults to
* the end of the snippet. Variables are defined with `$name` and
* `${name:default value}`.
*
* @since 3.18.0
*/
export interface StringValue {
/**
* The kind of string value.
*/
kind: "snippet";
/**
* The snippet string.
*/
value: string;
}
/**
* Represents information about programming constructs like variables, classes,
* interfaces etc.
*/
export interface SymbolInformation {
/**
* The name of this symbol.
*/
name: string;
/**
* The kind of this symbol.
*/
kind: SymbolKind;
/**
* Tags for this symbol.
*
* @since 3.16.0
*/
tags?: SymbolTag[] | undefined;
/**
* The name of the symbol containing this symbol. This information is for
* user interface purposes (e.g. to render a qualifier in the user interface
* if necessary). It can't be used to re-infer a hierarchy for the document
* symbols.
*/
containerName?: string | undefined;
/**
* Indicates if this symbol is deprecated.
*
* @deprecated Use tags instead
*/
deprecated?: boolean | undefined;
/**
* The location of this symbol. The location's range is used by a tool
* to reveal the location in the editor. If the symbol is selected in the
* tool the range's start information is used to position the cursor. So
* the range usually spans more than the actual symbol's name and does
* normally include things like visibility modifiers.
*
* The range doesn't have to denote a node range in the sense of an abstract
* syntax tree. It can therefore not be used to re-construct a hierarchy of
* the symbols.
*/
location: Location;
}
/**
* A symbol kind.
*/
export type SymbolKind = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26;
/**
* Symbol tags are extra annotations that tweak the rendering of a symbol.
*
* @since 3.16
*/
export type SymbolTag = 1;
/**
* Describes textual changes on a text document. A TextDocumentEdit describes all changes
* on a document version Si and after they are applied move the document to version Si+1.
* So the creator of a TextDocumentEdit doesn't need to sort the array of edits or do any
* kind of ordering. However the edits must be non overlapping.
*/
export interface TextDocumentEdit {
/**
* The text document to change.
*/
textDocument: OptionalVersionedTextDocumentIdentifier;
/**
* The edits to be applied.
*
* @since 3.16.0 - support for AnnotatedTextEdit. This is guarded using a
* client capability.
*
* @since 3.18.0 - support for SnippetTextEdit. This is guarded using a
* client capability.
*/
edits: (TextEdit | AnnotatedTextEdit | SnippetTextEdit)[];
}
/**
* A literal to identify a text document in the client.
*/
export interface TextDocumentIdentifier {
/**
* The text document's uri.
*/
uri: DocumentUri;
}
/**
* A parameter literal used in requests to pass a text document and a position inside that
* document.
*/
export interface TextDocumentPositionParams {
/**
* The text document.
*/
textDocument: TextDocumentIdentifier;
/**
* The position inside the text document.
*/
position: Position;
}
/**
* A text edit applicable to a text document.
*/
export interface TextEdit {
/**
* The range of the text document to be manipulated. To insert
* text into a document create a range where start === end.
*/
range: Range;
/**
* The string to be inserted. For delete operations use an
* empty string.
*/
newText: string;
}
export interface TypeDefinitionParams {
/**
* The text document.
*/
textDocument: TextDocumentIdentifier;
/**
* The position inside the text document.
*/
position: Position;
/**
* An optional token that a server can use to report work done progress.
*/
workDoneToken?: ProgressToken | undefined;
/**
* An optional token that a server can use to report partial results (e.g. streaming) to
* the client.
*/
partialResultToken?: ProgressToken | undefined;
}
export type URI = string;
/**
* A diagnostic report indicating that the last returned
* report is still accurate.
*
* @since 3.17.0
*/
export interface UnchangedDocumentDiagnosticReport {
/**
* A document diagnostic report indicating
* no changes to the last result. A server can
* only return `unchanged` if result ids are
* provided.
*/
kind: "unchanged";
/**
* A result id which will be sent on the next
* diagnostic request for the same document.
*/
resultId: string;
}
/**
* A classified text element containing an array of classified text runs, used for colorized labels in VS.
*/
export interface VSClassifiedTextElement {
/**
* The classified text runs that make up this element.
*/
Runs: VSClassifiedTextRun[];
/**
* VS type discriminator required by ObjectContentConverter for deserialization.
*/
_vs_type: "ClassifiedTextElement";
}
/**
* A classified text run with text and classification type, used for colorized display in VS.
*/
export interface VSClassifiedTextRun {
/**
* The classification type name (e.g. 'keyword', 'class name', 'parameter name').
*/
ClassificationTypeName: string;
/**
* The text content of this run.
*/
Text: string;
/**
* Optional marker tag type.
*/
MarkerTagType?: string | undefined;
/**
* The style of this text run.
*/
Style?: number | undefined;
/**
* VS type discriminator required by ObjectContentConverter for deserialization.
*/
_vs_type: "ClassifiedTextRun";
}
/**
* A container element that groups other VS rich-content elements (images, classified text, or nested containers). Used to build the VS hover raw content that combines a symbol icon with colorized text.
*/
export interface VSContainerElement {
/**
* Layout style for the child elements.
*/
Style: VSContainerElementStyle;
/**
* The child elements contained within this container.
*/
Elements: (VSImageElement | VSClassifiedTextElement | VSContainerElement)[];
/**
* VS type discriminator required by ObjectContentConverter for deserialization.
*/
_vs_type: "ContainerElement";
}
/**
* Layout style for a VSContainerElement's children, mirroring VS's Microsoft.VisualStudio.Text.Adornments.ContainerElementStyle.
*/
export type VSContainerElementStyle = 0 | 1;
/**
* An image element (e.g. a symbol-kind icon) for use in VS rich content such as hover tooltips.
*/
export interface VSImageElement {
/**
* The image to display.
*/
ImageId: VSImageId;
/**
* VS type discriminator required by ObjectContentConverter for deserialization.
*/
_vs_type: "ImageElement";
}
/**
* Identifies an image in a VS image catalog. Used to render symbol-kind icons (e.g. in hover tooltips).
*/
export interface VSImageId {
/**
* The GUID of the image catalog containing this image.
*/
Guid: string;
/**
* The numeric identifier of the image within its catalog.
*/
Id: number;
/**
* VS type discriminator required by ObjectContentConverter for deserialization.
*/
_vs_type: "ImageId";
}
/**
* Parameters for the textDocument/_vs_onAutoInsert request.
*/
export interface VSOnAutoInsertParams {
/**
* The text document.
*/
_vs_textDocument: TextDocumentIdentifier;
/**
* The position inside the text document.
*/
_vs_position: Position;
/**
* The character that triggered the auto-insert.
*/
_vs_ch: string;
}
/**
* Response item for the textDocument/_vs_onAutoInsert request.
*/
export interface VSOnAutoInsertResponseItem {
/**
* The format of the text edit (plaintext or snippet).
*/
_vs_textEditFormat: InsertTextFormat;
/**
* The text edit to apply for the auto-insertion.
*/
_vs_textEdit: TextEdit;
}
/**
* A VS-specific reference item with grouping support for Find All References.
*/
export interface VSReferenceItem {
/**
* Unique identifier for this reference item.
*/
_vs_id: number;
/**
* The ID of the definition item this reference belongs to. Absent for definition items themselves.
*/
_vs_definitionId?: number | undefined;
/**
* The kind(s) of this reference (read, write, etc.).
*/
_vs_kind?: VSReferenceKind[] | undefined;
/**
* The location of this reference.
*/
_vs_location: Location;
/**
* Classified display text for the definition (used for grouping headers in the UI).
*/
_vs_definitionText?: VSClassifiedTextElement | undefined;
/**
* The project name for this reference.
*/
_vs_projectName?: string | undefined;
/**
* The containing type for this reference.
*/
_vs_containingType?: string | undefined;
}
export type VSReferenceKind = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17;
/**
* A workspace edit represents changes to many resources managed in the workspace. The edit
* should either provide `changes` or `documentChanges`. If documentChanges are present
* they are preferred over `changes` if the client can handle versioned document edits.
*
* Since version 3.13.0 a workspace edit can contain resource operations as well. If resource
* operations are present clients need to execute the operations in the order in which they
* are provided. So a workspace edit for example can consist of the following two changes:
* (1) a create file a.txt and (2) a text document edit which insert text into file a.txt.
*
* An invalid sequence (e.g. (1) delete file a.txt and (2) insert text into file a.txt) will
* cause failure of the operation. How the client recovers from the failure is described by
* the client capability: `workspace.workspaceEdit.failureHandling`
*/
export interface WorkspaceEdit {
/**
* Holds changes to existing resources.
*/
changes?: {
[key: DocumentUri]: TextEdit[];
} | undefined;
/**
* Depending on the client capability `workspace.workspaceEdit.resourceOperations` document changes
* are either an array of `TextDocumentEdit`s to express changes to n different text documents
* where each text document edit addresses a specific version of a text document. Or it can contain
* above `TextDocumentEdit`s mixed with create, rename and delete file / folder operations.
*
* Whether a client supports versioned document edits is expressed via
* `workspace.workspaceEdit.documentChanges` client capability.
*
* If a client neither supports `documentChanges` nor `workspace.workspaceEdit.resourceOperations` then
* only plain `TextEdit`s using the `changes` property are supported.
*/
documentChanges?: (TextDocumentEdit | CreateFile | RenameFile | DeleteFile)[] | undefined;
/**
* A map of change annotations that can be referenced in `AnnotatedTextEdit`s or create, rename and
* delete file / folder operations.
*
* Whether clients honor this property depends on the client capability `workspace.changeAnnotationSupport`.
*
* @since 3.16.0
*/
changeAnnotations?: {
[key: ChangeAnnotationIdentifier]: ChangeAnnotation;
} | undefined;
}
/**
* A special workspace symbol that supports locations without a range.
*
* See also SymbolInformation.
*
* @since 3.17.0
*/
export interface WorkspaceSymbol {
/**
* The name of this symbol.
*/
name: string;
/**
* The kind of this symbol.
*/
kind: SymbolKind;
/**
* Tags for this symbol.
*
* @since 3.16.0
*/
tags?: SymbolTag[] | undefined;
/**
* The name of the symbol containing this symbol. This information is for
* user interface purposes (e.g. to render a qualifier in the user interface
* if necessary). It can't be used to re-infer a hierarchy for the document
* symbols.
*/
containerName?: string | undefined;
/**
* The location of the symbol. Whether a server is allowed to
* return a location without a range depends on the client
* capability `workspace.symbol.resolveSupport`.
*
* See SymbolInformation#location for more details.
*/
location: Location | LocationUriOnly;
/**
* A data entry field that is preserved on a workspace symbol between a
* workspace symbol request and a workspace symbol resolve request.
*/
data?: LSPAny | undefined;
}
/**
* The parameters of a {@link WorkspaceSymbolRequest}.
*/
export interface WorkspaceSymbolParams {
/**
* An optional token that a server can use to report work done progress.
*/
workDoneToken?: ProgressToken | undefined;
/**
* An optional token that a server can use to report partial results (e.g. streaming) to
* the client.
*/
partialResultToken?: ProgressToken | undefined;
/**
* A query string to filter symbols by. Clients may send an empty
* string here to request all symbols.
*
* The `query`-parameter should be interpreted in a *relaxed way* as editors
* will apply their own highlighting and scoring on the results. A good rule
* of thumb is to match case-insensitive and to simply check that the
* characters of *query* appear in their order in a candidate symbol.
* Servers shouldn't use prefix, substring, or similar strict matching.
*/
query: string;
/**
* Scopes the workspace symbol search to projects containing this document.
*/
textDocument?: TextDocumentIdentifier | undefined;
}
/** Language-feature requests supported by the extension middleware API. */
export interface LspMiddlewareRequests {
"textDocument/hover": {
params: HoverParams;
result: Hover | null;
};
"textDocument/completion": {
params: CompletionParams;
result: CompletionItem[] | CompletionList | null;
};
"completionItem/resolve": {
params: CompletionItem;
result: CompletionItem;
};
"textDocument/signatureHelp": {
params: SignatureHelpParams;
result: SignatureHelp | null;
};
"textDocument/definition": {
params: DefinitionParams;
result: Definition | DefinitionLink[] | null;
};
"textDocument/typeDefinition": {
params: TypeDefinitionParams;
result: Definition | DefinitionLink[] | null;
};
"textDocument/implementation": {
params: ImplementationParams;
result: Definition | DefinitionLink[] | null;
};
"textDocument/references": {
params: ReferenceParams;
result: Location[] | null;
};
"textDocument/documentHighlight": {
params: DocumentHighlightParams;
result: DocumentHighlight[] | null;
};
"textDocument/documentSymbol": {
params: DocumentSymbolParams;
result: SymbolInformation[] | DocumentSymbol[] | null;
};
"workspace/symbol": {
params: WorkspaceSymbolParams;
result: SymbolInformation[] | WorkspaceSymbol[] | null;
};
"textDocument/rename": {
params: RenameParams;
result: WorkspaceEdit | null;
};
"textDocument/prepareRename": {
params: PrepareRenameParams;
result: PrepareRenameResult | null;
};
"textDocument/formatting": {
params: DocumentFormattingParams;
result: TextEdit[] | null;
};
"textDocument/rangeFormatting": {
params: DocumentRangeFormattingParams;
result: TextEdit[] | null;
};
"textDocument/onTypeFormatting": {
params: DocumentOnTypeFormattingParams;
result: TextEdit[] | null;
};
"textDocument/selectionRange": {
params: SelectionRangeParams;
result: SelectionRange[] | null;
};
"textDocument/foldingRange": {
params: FoldingRangeParams;
result: FoldingRange[] | null;
};
"textDocument/inlayHint": {
params: InlayHintParams;
result: InlayHint[] | null;
};
"textDocument/codeAction": {
params: CodeActionParams;
result: (Command | CodeAction)[] | null;
};
"textDocument/codeLens": {
params: CodeLensParams;
result: CodeLens[] | null;
};
"codeLens/resolve": {
params: CodeLens;
result: CodeLens;
};
"textDocument/prepareCallHierarchy": {
params: CallHierarchyPrepareParams;
result: CallHierarchyItem[] | null;
};
"callHierarchy/incomingCalls": {
params: CallHierarchyIncomingCallsParams;
result: CallHierarchyIncomingCall[] | null;
};
"callHierarchy/outgoingCalls": {
params: CallHierarchyOutgoingCallsParams;
result: CallHierarchyOutgoingCall[] | null;
};
"textDocument/linkedEditingRange": {
params: LinkedEditingRangeParams;
result: LinkedEditingRanges | null;
};
"textDocument/semanticTokens/full": {
params: SemanticTokensParams;
result: SemanticTokens | null;
};
"textDocument/semanticTokens/range": {
params: SemanticTokensRangeParams;
result: SemanticTokens | null;
};
"textDocument/diagnostic": {
params: DocumentDiagnosticParams;
result: DocumentDiagnosticReport;
};
"custom/textDocument/sourceDefinition": {
params: TextDocumentPositionParams;
result: Definition | DefinitionLink[] | null;
};
"custom/textDocument/multiDocumentHighlight": {
params: MultiDocumentHighlightParams;
result: MultiDocumentHighlight[] | null;
};
"textDocument/_vs_onAutoInsert": {
params: VSOnAutoInsertParams;
result: VSOnAutoInsertResponseItem | null;
};
"textDocument/_vs_references": {
params: ReferenceParams;
result: VSReferenceItem[] | null;
};
}
//# sourceMappingURL=protocol.generated.d.ts.map