Typings Reference

export type DocumentUri = string;

export type integer = number;

export type uinteger = number;

export type decimal = number;

export type LSPAny = any;

export type LSPObject = object;

export type LSPArray = any[];

export interface Position {
    line: uinteger;
    character: uinteger;
}

Members

line: uinteger;

Line position in a document (zero-based).

If a line number is greater than the number of lines in a document, it defaults back to the number of lines in the document. If a line number is negative, it defaults to 0.

character: uinteger;

Character offset on a line in a document (zero-based).

The meaning of this offset is determined by the negotiated PositionEncodingKind.

If the character value is greater than the line length it defaults back to the line length.

export interface Range {
    start: Position;
    end: Position;
}

Members

start: Position;

The range's start position.

end: Position;

The range's end position.

export interface Location {
    uri: DocumentUri;
    range: Range;
}

Members

uri: DocumentUri;

The document URI of the location.

range: Range;

The range of the location.

export interface LocationLink {
    originSelectionRange?: Range;
    targetUri: DocumentUri;
    targetRange: Range;
    targetSelectionRange: Range;
}

Members

originSelectionRange?: Range;

Span of the origin of this link.

Used as the underlined span for mouse interaction. Defaults to the word range at the definition position.

targetUri: DocumentUri;

The target resource identifier of this link.

targetRange: Range;

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.

targetSelectionRange: 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

export interface Color {
    readonly red: decimal;
    readonly green: decimal;
    readonly blue: decimal;
    readonly alpha: decimal;
}

Members

readonly red: decimal;

The red component of this color in the range [0-1].

readonly green: decimal;

The green component of this color in the range [0-1].

readonly blue: decimal;

The blue component of this color in the range [0-1].

readonly alpha: decimal;

The alpha component of this color in the range [0-1].

export interface ColorInformation {
    range: Range;
    color: Color;
}

Members

range: Range;

The range in the document where this color appears.

color: Color;

The actual color value for this color range.

export interface ColorPresentation {
    label: string;
    textEdit?: TextEdit;
    additionalTextEdits?: TextEdit[];
}

Members

label: string;

The label of this color presentation. It will be shown on the color picker header. By default this is also the text that is inserted when selecting this color presentation.

textEdit?: TextEdit;

An edit which is applied to a document when selecting this presentation for the color. When falsy the label is used.

additionalTextEdits?: TextEdit[];

An optional array of additional text edits that are applied when selecting this color presentation. Edits must not overlap with the main edit nor with themselves.

export type FoldingRangeKind = string;

export interface FoldingRange {
    startLine: uinteger;
    startCharacter?: uinteger;
    endLine: uinteger;
    endCharacter?: uinteger;
    kind?: FoldingRangeKind;
    collapsedText?: string;
}

Members

startLine: uinteger;

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.

startCharacter?: uinteger;

The zero-based character offset from where the folded range starts. If not defined, defaults to the length of the start line.

endLine: uinteger;

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.

endCharacter?: uinteger;

The zero-based character offset before the folded range ends. If not defined, defaults to the length of the end line.

kind?: FoldingRangeKind;

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 FoldingRangeKind for an enumeration of standardized kinds.

collapsedText?: string;

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.

export interface DiagnosticRelatedInformation {
    location: Location;
    message: string;
}

Members

location: Location;

The location of this related diagnostic information.

message: string;

The message of this related diagnostic information.

export type DiagnosticSeverity = 1 | 2 | 3 | 4;

export type DiagnosticTag = 1 | 2;

export interface CodeDescription {
    href: string;
}

Members

href: string;

An URI to open with more information about the diagnostic error.

export interface Diagnostic {
    range: Range;
    severity?: DiagnosticSeverity;
    code?: integer | string;
    codeDescription?: CodeDescription;
    source?: string;
    message: string;
    tags?: DiagnosticTag[];
    relatedInformation?: DiagnosticRelatedInformation[];
    data?: LSPAny;
}

Members

range: Range;

The range at which the message applies

severity?: DiagnosticSeverity;

The diagnostic's severity. Can be omitted. If omitted it is up to the client to interpret diagnostics as error, warning, info or hint.

code?: integer | string;

The diagnostic's code, which usually appear in the user interface.

codeDescription?: CodeDescription;

An optional property to describe the error code. Requires the code field (above) to be present/not null.

source?: string;

A human-readable string describing the source of this diagnostic, e.g. 'typescript' or 'super lint'. It usually appears in the user interface.

message: string;

The diagnostic's message. It usually appears in the user interface

tags?: DiagnosticTag[];

Additional metadata about the diagnostic.

relatedInformation?: DiagnosticRelatedInformation[];

An array of related diagnostic information, e.g. when symbol-names within a scope collide all definitions can be marked via this property.

data?: LSPAny;

A data entry field that is preserved between a textDocument/publishDiagnostics notification and textDocument/codeAction request.

export interface Command {
    title: string;
    command: string;
    arguments?: LSPAny[];
}

Members

title: string;

Title of the command, like save.

command: string;

The identifier of the actual command handler.

arguments?: LSPAny[];

Arguments that the command handler should be invoked with.

export interface TextEdit {
    range: Range;
    newText: string;
}

Members

range: Range;

The range of the text document to be manipulated. To insert text into a document create a range where start === end.

newText: string;

The string to be inserted. For delete operations use an empty string.

export interface ChangeAnnotation {
    label: string;
    needsConfirmation?: boolean;
    description?: string;
}

Members

label: string;

A human-readable string describing the actual change. The string is rendered prominent in the user interface.

needsConfirmation?: boolean;

A flag which indicates that user confirmation is needed before applying the change.

description?: string;

A human-readable string which is rendered less prominent in the user interface.

export type ChangeAnnotationIdentifier = string;

export interface AnnotatedTextEdit extends TextEdit {
    annotationId: ChangeAnnotationIdentifier;
}

Members

annotationId: ChangeAnnotationIdentifier;

The actual identifier of the change annotation

export interface TextDocumentEdit {
    textDocument: OptionalVersionedTextDocumentIdentifier;
    edits: (TextEdit | AnnotatedTextEdit | SnippetTextEdit)[];
}

Members

textDocument: OptionalVersionedTextDocumentIdentifier;

The text document to change.

edits: (TextEdit | AnnotatedTextEdit | SnippetTextEdit)[];

The edits to be applied.

interface ResourceOperation {
    kind: string;
    annotationId?: ChangeAnnotationIdentifier;
}

Members

kind: string;

The resource operation kind.

annotationId?: ChangeAnnotationIdentifier;

An optional annotation identifier describing the operation.

export interface CreateFileOptions {
    overwrite?: boolean;
    ignoreIfExists?: boolean;
}

Members

overwrite?: boolean;

Overwrite existing file. Overwrite wins over ignoreIfExists

ignoreIfExists?: boolean;

Ignore if exists.

export interface CreateFile extends ResourceOperation {
    kind: 'create';
    uri: DocumentUri;
    options?: CreateFileOptions;
}

Members

kind: 'create';

A create

uri: DocumentUri;

The resource to create.

options?: CreateFileOptions;

Additional options

export interface RenameFileOptions {
    overwrite?: boolean;
    ignoreIfExists?: boolean;
}

Members

overwrite?: boolean;

Overwrite target if existing. Overwrite wins over ignoreIfExists

ignoreIfExists?: boolean;

Ignores if target exists.

export interface RenameFile extends ResourceOperation {
    kind: 'rename';
    oldUri: DocumentUri;
    newUri: DocumentUri;
    options?: RenameFileOptions;
}

Members

kind: 'rename';

A rename

oldUri: DocumentUri;

The old (existing) location.

newUri: DocumentUri;

The new location.

options?: RenameFileOptions;

Rename options.

export interface DeleteFileOptions {
    recursive?: boolean;
    ignoreIfNotExists?: boolean;
}

Members

recursive?: boolean;

Delete the content recursively if a folder is denoted.

ignoreIfNotExists?: boolean;

Ignore the operation if the file doesn't exist.

export interface DeleteFile extends ResourceOperation {
    kind: 'delete';
    uri: DocumentUri;
    options?: DeleteFileOptions;
}

Members

kind: 'delete';

A delete

uri: DocumentUri;

The file to delete.

options?: DeleteFileOptions;

Delete options.

export interface WorkspaceEdit {
    changes?: {
        [uri: DocumentUri]: TextEdit[];
    };
    documentChanges?: (TextDocumentEdit | CreateFile | RenameFile | DeleteFile)[];
    changeAnnotations?: {
        [id: ChangeAnnotationIdentifier]: ChangeAnnotation;
    };
}

Members

changes?: { [uri: DocumentUri]: TextEdit[]; };

Holds changes to existing resources.

documentChanges?: (TextDocumentEdit | CreateFile | RenameFile | DeleteFile)[];

Depending on the client capability workspace.workspaceEdit.resourceOperations document changes are either an array of TextDocumentEdits 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 TextDocumentEdits 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 TextEdits using the changes property are supported.

changeAnnotations?: { [id: ChangeAnnotationIdentifier]: ChangeAnnotation; };

A map of change annotations that can be referenced in AnnotatedTextEdits or create, rename and delete file / folder operations.

Whether clients honor this property depends on the client capability workspace.changeAnnotationSupport.

export interface TextEditChange {
    all(): (TextEdit | AnnotatedTextEdit)[];
    clear(): void;
    add(edit: TextEdit | AnnotatedTextEdit): void;
    insert(position: Position, newText: string): void;
    insert(position: Position, newText: string, annotation: ChangeAnnotation | ChangeAnnotationIdentifier): ChangeAnnotationIdentifier;
    replace(range: Range, newText: string): void;
    replace(range: Range, newText: string, annotation?: ChangeAnnotation | ChangeAnnotationIdentifier): ChangeAnnotationIdentifier;
    delete(range: Range): void;
    delete(range: Range, annotation?: ChangeAnnotation | ChangeAnnotationIdentifier): ChangeAnnotationIdentifier;
}

Members

all(): (TextEdit | AnnotatedTextEdit)[];

Gets all text edits for this change.

clear(): void;

Clears the edits for this change.

add(edit: TextEdit | AnnotatedTextEdit): void;

Adds a text edit.

insert(position: Position, newText: string): void;

Insert the given text at the given position.

insert(position: Position, newText: string, annotation: ChangeAnnotation | ChangeAnnotationIdentifier): ChangeAnnotationIdentifier;

Insert the given text at the given position with an annotation.

replace(range: Range, newText: string): void;

Replace the given range with given text for the given resource.

replace(range: Range, newText: string, annotation?: ChangeAnnotation | ChangeAnnotationIdentifier): ChangeAnnotationIdentifier;

Replace the given range with given text with an annotation.

delete(range: Range): void;

Delete the text at the given range.

delete(range: Range, annotation?: ChangeAnnotation | ChangeAnnotationIdentifier): ChangeAnnotationIdentifier;

Delete the text at the given range with an annotation.

export class WorkspaceChange {
    private _workspaceEdit;
    private _textEditChanges;
    private _changeAnnotations;
    constructor(workspaceEdit?: WorkspaceEdit);
    get edit(): WorkspaceEdit;
    getTextEditChange(textDocument: OptionalVersionedTextDocumentIdentifier): TextEditChange;
    getTextEditChange(uri: DocumentUri): TextEditChange;
    private initDocumentChanges;
    private initChanges;
    createFile(uri: DocumentUri, options?: CreateFileOptions): void;
    createFile(uri: DocumentUri, annotation: ChangeAnnotation | ChangeAnnotationIdentifier, options?: CreateFileOptions): ChangeAnnotationIdentifier;
    renameFile(oldUri: DocumentUri, newUri: DocumentUri, options?: RenameFileOptions): void;
    renameFile(oldUri: DocumentUri, newUri: DocumentUri, annotation?: ChangeAnnotation | ChangeAnnotationIdentifier, options?: RenameFileOptions): ChangeAnnotationIdentifier;
    deleteFile(uri: DocumentUri, options?: DeleteFileOptions): void;
    deleteFile(uri: DocumentUri, annotation: ChangeAnnotation | ChangeAnnotationIdentifier, options?: DeleteFileOptions): ChangeAnnotationIdentifier;
}

Members

private _workspaceEdit;

private _textEditChanges;

private _changeAnnotations;

constructor(workspaceEdit?: WorkspaceEdit);

get edit(): WorkspaceEdit;

Returns the underlying WorkspaceEdit literal use to be returned from a workspace edit operation like rename.

getTextEditChange(textDocument: OptionalVersionedTextDocumentIdentifier): TextEditChange;

Returns the TextEditChange to manage text edits for resources.

getTextEditChange(uri: DocumentUri): TextEditChange;

private initDocumentChanges;

private initChanges;

createFile(uri: DocumentUri, options?: CreateFileOptions): void;

Create a file in the workspace edit.

createFile(uri: DocumentUri, annotation: ChangeAnnotation | ChangeAnnotationIdentifier, options?: CreateFileOptions): ChangeAnnotationIdentifier;

Create a file in the workspace edit with an annotation.

renameFile(oldUri: DocumentUri, newUri: DocumentUri, options?: RenameFileOptions): void;

Rename a file in the workspace edit.

renameFile(oldUri: DocumentUri, newUri: DocumentUri, annotation?: ChangeAnnotation | ChangeAnnotationIdentifier, options?: RenameFileOptions): ChangeAnnotationIdentifier;

Rename a file in the workspace edit with an annotation.

deleteFile(uri: DocumentUri, options?: DeleteFileOptions): void;

Delete a file in the workspace edit.

deleteFile(uri: DocumentUri, annotation: ChangeAnnotation | ChangeAnnotationIdentifier, options?: DeleteFileOptions): ChangeAnnotationIdentifier;

Delete a file in the workspace edit with an annotation.

export interface TextDocumentIdentifier {
    uri: DocumentUri;
}

Members

uri: DocumentUri;

The text document's uri.

export interface VersionedTextDocumentIdentifier extends TextDocumentIdentifier {
    version: integer;
}

Members

version: integer;

The version number of this document.

export interface OptionalVersionedTextDocumentIdentifier extends TextDocumentIdentifier {
    version: integer | null;
}

Members

version: integer | null;

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).

export interface TextDocumentItem {
    uri: DocumentUri;
    languageId: string;
    version: integer;
    text: string;
}

Members

uri: DocumentUri;

The text document's uri.

languageId: string;

The text document's language identifier.

version: integer;

The version number of this document (it will increase after each change, including undo/redo).

text: string;

The content of the opened text document.

export type MarkupKind = 'plaintext' | 'markdown';

export interface MarkupContent {
    kind: MarkupKind;
    value: string;
}

Members

kind: MarkupKind;

The type of the Markup

value: string;

The content itself

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;

export type InsertTextFormat = 1 | 2;

export type CompletionItemTag = 1;

export interface InsertReplaceEdit {
    newText: string;
    insert: Range;
    replace: Range;
}

Members

newText: string;

The string to be inserted.

insert: Range;

The range if the insert is requested

replace: Range;

The range if the replace is requested.

export type InsertTextMode = 1 | 2;

export interface CompletionItemLabelDetails {
    detail?: string;
    description?: string;
}

Members

detail?: string;

An optional string which is rendered less prominently directly after label, without any spacing. Should be used for function signatures and type annotations.

description?: string;

An optional string which is rendered less prominently after . Should be used for fully qualified names and file paths.

export interface CompletionItem {
    label: string;
    labelDetails?: CompletionItemLabelDetails;
    kind?: CompletionItemKind;
    tags?: CompletionItemTag[];
    detail?: string;
    documentation?: string | MarkupContent;
    deprecated?: boolean;
    preselect?: boolean;
    sortText?: string;
    filterText?: string;
    insertText?: string;
    insertTextFormat?: InsertTextFormat;
    insertTextMode?: InsertTextMode;
    textEdit?: TextEdit | InsertReplaceEdit;
    textEditText?: string;
    additionalTextEdits?: TextEdit[];
    commitCharacters?: string[];
    command?: Command;
    data?: LSPAny;
}

Members

label: string;

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.

labelDetails?: CompletionItemLabelDetails;

Additional details for the label

kind?: CompletionItemKind;

The kind of this completion item. Based of the kind an icon is chosen by the editor.

tags?: CompletionItemTag[];

Tags for this completion item.

detail?: string;

A human-readable string with additional information about this item, like type or symbol information.

documentation?: string | MarkupContent;

A human-readable string that represents a doc-comment.

deprecated?: boolean;

Indicates if this item is deprecated.

preselect?: boolean;

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.

sortText?: string;

A string that should be used when comparing this item with other items. When falsy the label is used.

filterText?: string;

A string that should be used when filtering a set of completion items. When falsy the label is used.

insertText?: string;

A string that should be inserted into a document when selecting this completion. When falsy the 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.

insertTextFormat?: InsertTextFormat;

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.

insertTextMode?: InsertTextMode;

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.

textEdit?: TextEdit | InsertReplaceEdit;

An edit which is applied to a document when selecting this completion. When an edit is provided the value of 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.

textEditText?: string;

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.

additionalTextEdits?: TextEdit[];

An optional array of additional text edits that are applied when selecting this completion. Edits must not overlap (including the same insert position) with the main 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).

commitCharacters?: string[];

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.

command?: Command;

An optional command that is executed after inserting this completion. Note that additional modifications to the current document should be described with the additionalTextEdits-property.

data?: LSPAny;

A data entry field that is preserved on a completion item between a CompletionRequest and a CompletionResolveRequest.

export interface CompletionList {
    isIncomplete: boolean;
    itemDefaults?: {
        commitCharacters?: string[];
        editRange?: Range | {
            insert: Range;
            replace: Range;
        };
        insertTextFormat?: InsertTextFormat;
        insertTextMode?: InsertTextMode;
        data?: LSPAny;
    };
    items: CompletionItem[];
}

Members

isIncomplete: boolean;

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.

itemDefaults?: { commitCharacters?: string[]; editRange?: Range | { insert: Range; replace: Range; }; insertTextFormat?: InsertTextFormat; insertTextMode?: InsertTextMode; data?: LSPAny; };

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 one from the item is used.

Servers are only allowed to return default values if the client signals support for this via the completionList.itemDefaults capability.

items: CompletionItem[];

The completion items.

export type MarkedString = string | {
    language: string;
    value: string;
};

export interface Hover {
    contents: MarkupContent | MarkedString | MarkedString[];
    range?: Range;
}

Members

contents: MarkupContent | MarkedString | MarkedString[];

The hover's content

range?: Range;

An optional range inside the text document that is used to visualize the hover, e.g. by changing the background color.

export interface ParameterInformation {
    label: string | [
        uinteger,
        uinteger
    ];
    documentation?: string | MarkupContent;
}

Members

label: string | [ uinteger, uinteger ];

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.

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.

documentation?: string | MarkupContent;

The human-readable doc-comment of this parameter. Will be shown in the UI but can be omitted.

export interface SignatureInformation {
    label: string;
    documentation?: string | MarkupContent;
    parameters?: ParameterInformation[];
    activeParameter?: uinteger;
}

Members

label: string;

The label of this signature. Will be shown in the UI.

documentation?: string | MarkupContent;

The human-readable doc-comment of this signature. Will be shown in the UI but can be omitted.

parameters?: ParameterInformation[];

The parameters of this signature.

activeParameter?: uinteger;

The index of the active parameter.

If provided, this is used in place of SignatureHelp.activeParameter.

export interface SignatureHelp {
    signatures: SignatureInformation[];
    activeSignature?: uinteger;
    activeParameter?: uinteger;
}

Members

signatures: SignatureInformation[];

One or more signatures.

activeSignature?: uinteger;

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.

activeParameter?: uinteger;

The active parameter of the active signature. 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 to better express the active parameter if the active signature does have any.

export type Definition = Location | Location[];

export type DefinitionLink = LocationLink;

export type Declaration = Location | Location[];

export type DeclarationLink = LocationLink;

export interface ReferenceContext {
    includeDeclaration: boolean;
}

Members

includeDeclaration: boolean;

Include the declaration of the current symbol.

export type DocumentHighlightKind = 1 | 2 | 3;

export interface DocumentHighlight {
    range: Range;
    kind?: DocumentHighlightKind;
}

Members

range: Range;

The range this highlight applies to.

kind?: DocumentHighlightKind;

The highlight kind, default is text.

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;

export type SymbolTag = 1;

export interface BaseSymbolInformation {
    name: string;
    kind: SymbolKind;
    tags?: SymbolTag[];
    containerName?: string;
}

Members

name: string;

The name of this symbol.

kind: SymbolKind;

The kind of this symbol.

tags?: SymbolTag[];

Tags for this symbol.

containerName?: string;

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.

export interface SymbolInformation extends BaseSymbolInformation {
    deprecated?: boolean;
    location: Location;
}

Members

deprecated?: boolean;

Indicates if this symbol is deprecated.

location: Location;

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.

export interface WorkspaceSymbol extends BaseSymbolInformation {
    location: Location | {
        uri: DocumentUri;
    };
    data?: LSPAny;
}

Members

location: Location | { uri: DocumentUri; };

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.

data?: LSPAny;

A data entry field that is preserved on a workspace symbol between a workspace symbol request and a workspace symbol resolve request.

export interface DocumentSymbol {
    name: string;
    detail?: string;
    kind: SymbolKind;
    tags?: SymbolTag[];
    deprecated?: boolean;
    range: Range;
    selectionRange: Range;
    children?: DocumentSymbol[];
}

Members

name: string;

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.

detail?: string;

More detail for this symbol, e.g the signature of a function.

kind: SymbolKind;

The kind of this symbol.

tags?: SymbolTag[];

Tags for this document symbol.

deprecated?: boolean;

Indicates if this symbol is deprecated.

range: Range;

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.

selectionRange: 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.

children?: DocumentSymbol[];

Children of this symbol, e.g. properties of a class.

export type CodeActionKind = string;

export type CodeActionTriggerKind = 1 | 2;

export interface CodeActionContext {
    diagnostics: Diagnostic[];
    only?: CodeActionKind[];
    triggerKind?: CodeActionTriggerKind;
}

Members

diagnostics: Diagnostic[];

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.

only?: CodeActionKind[];

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.

triggerKind?: CodeActionTriggerKind;

The reason why code actions were requested.

export interface CodeAction {
    title: string;
    kind?: CodeActionKind;
    diagnostics?: Diagnostic[];
    isPreferred?: boolean;
    disabled?: {
        reason: string;
    };
    edit?: WorkspaceEdit;
    command?: Command;
    data?: LSPAny;
}

Members

title: string;

A short, human-readable, title for this code action.

kind?: CodeActionKind;

The kind of the code action.

Used to filter code actions.

diagnostics?: Diagnostic[];

The diagnostics that this code action resolves.

isPreferred?: boolean;

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.

disabled?: { reason: string; };

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 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 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.

edit?: WorkspaceEdit;

The workspace edit this code action performs.

command?: Command;

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.

data?: LSPAny;

A data entry field that is preserved on a code action between a textDocument/codeAction and a codeAction/resolve request.

export interface CodeLens {
    range: Range;
    command?: Command;
    data?: LSPAny;
}

Members

range: Range;

The range in which this code lens is valid. Should only span a single line.

command?: Command;

The command this code lens represents.

data?: LSPAny;

A data entry field that is preserved on a code lens item between a CodeLensRequest and a CodeLensResolveRequest.

export interface FormattingOptions {
    tabSize: uinteger;
    insertSpaces: boolean;
    trimTrailingWhitespace?: boolean;
    insertFinalNewline?: boolean;
    trimFinalNewlines?: boolean;
    [key: string]: boolean | integer | string | undefined;
}

Members

tabSize: uinteger;

Size of a tab in spaces.

insertSpaces: boolean;

Prefer spaces over tabs.

trimTrailingWhitespace?: boolean;

Trim trailing whitespace on a line.

insertFinalNewline?: boolean;

Insert a newline character at the end of the file if one does not exist.

trimFinalNewlines?: boolean;

Trim all newlines after the final newline at the end of the file.

[key: string]: boolean | integer | string | undefined;

Signature for further properties.

export interface DocumentLink {
    range: Range;
    target?: string;
    tooltip?: string;
    data?: LSPAny;
}

Members

range: Range;

The range this link applies to.

target?: string;

The uri this link points to. If missing a resolve request is sent later.

tooltip?: string;

The tooltip text when you hover over this link.

If a tooltip is provided, is will be displayed in a string that includes instructions on how to trigger the link, such as {0} (ctrl + click). The specific instructions vary depending on OS, user settings, and localization.

data?: LSPAny;

A data entry field that is preserved on a document link between a DocumentLinkRequest and a DocumentLinkResolveRequest.

export interface SelectionRange {
    range: Range;
    parent?: SelectionRange;
}

Members

range: Range;

The range of this selection range.

parent?: SelectionRange;

The parent selection range containing this range. Therefore parent.range must contain this.range.

export interface CallHierarchyItem {
    name: string;
    kind: SymbolKind;
    tags?: SymbolTag[];
    detail?: string;
    uri: DocumentUri;
    range: Range;
    selectionRange: Range;
    data?: LSPAny;
}

Members

name: string;

The name of this item.

kind: SymbolKind;

The kind of this item.

tags?: SymbolTag[];

Tags for this item.

detail?: string;

More detail for this item, e.g. the signature of a function.

uri: DocumentUri;

The resource identifier of this item.

range: Range;

The range enclosing this symbol not including leading/trailing whitespace but everything else, e.g. comments and code.

selectionRange: 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.

data?: LSPAny;

A data entry field that is preserved between a call hierarchy prepare and incoming calls or outgoing calls requests.

export interface CallHierarchyIncomingCall {
    from: CallHierarchyItem;
    fromRanges: Range[];
}

Members

from: CallHierarchyItem;

The item that makes the call.

fromRanges: Range[];

The ranges at which the calls appear. This is relative to the caller denoted by this.from.

export interface CallHierarchyOutgoingCall {
    to: CallHierarchyItem;
    fromRanges: Range[];
}

Members

to: CallHierarchyItem;

The item that is called.

fromRanges: Range[];

The range at which this item is called. This is the range relative to the caller, e.g the item passed to provideCallHierarchyOutgoingCalls and not this.to.

export enum SemanticTokenTypes {
    namespace = "namespace",
    type = "type",
    class = "class",
    enum = "enum",
    interface = "interface",
    struct = "struct",
    typeParameter = "typeParameter",
    parameter = "parameter",
    variable = "variable",
    property = "property",
    enumMember = "enumMember",
    event = "event",
    function = "function",
    method = "method",
    macro = "macro",
    keyword = "keyword",
    modifier = "modifier",
    comment = "comment",
    string = "string",
    number = "number",
    regexp = "regexp",
    operator = "operator",
    decorator = "decorator",
    label = "label"
}

Members

namespace = "namespace"

type = "type"

Represents a generic type. Acts as a fallback for types which can't be mapped to a specific type like class or enum.

class = "class"

enum = "enum"

interface = "interface"

struct = "struct"

typeParameter = "typeParameter"

parameter = "parameter"

variable = "variable"

property = "property"

enumMember = "enumMember"

event = "event"

function = "function"

method = "method"

macro = "macro"

keyword = "keyword"

modifier = "modifier"

comment = "comment"

string = "string"

number = "number"

regexp = "regexp"

operator = "operator"

decorator = "decorator"

label = "label"

export enum SemanticTokenModifiers {
    declaration = "declaration",
    definition = "definition",
    readonly = "readonly",
    static = "static",
    deprecated = "deprecated",
    abstract = "abstract",
    async = "async",
    modification = "modification",
    documentation = "documentation",
    defaultLibrary = "defaultLibrary"
}

Members

declaration = "declaration"

definition = "definition"

readonly = "readonly"

static = "static"

deprecated = "deprecated"

abstract = "abstract"

async = "async"

modification = "modification"

documentation = "documentation"

defaultLibrary = "defaultLibrary"

export interface SemanticTokensLegend {
    tokenTypes: string[];
    tokenModifiers: string[];
}

Members

tokenTypes: string[];

The token types a server uses.

tokenModifiers: string[];

The token modifiers a server uses.

export interface SemanticTokens {
    resultId?: string;
    data: uinteger[];
}

Members

resultId?: string;

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.

data: uinteger[];

The actual tokens.