vscode-languageserver-types

  • Version 3.17.5
  • Published
  • 377 kB
  • No dependencies
  • MIT license

Install

npm i vscode-languageserver-types
yarn add vscode-languageserver-types
pnpm add vscode-languageserver-types

Overview

Types used by the Language server for node

Index

Variables

Classes

Interfaces

Enums

Type Aliases

Namespaces

Variables

variable EOL

const EOL: string[];

    Classes

    class WorkspaceChange

    class WorkspaceChange {}
    • A workspace change helps constructing changes to a workspace.

    constructor

    constructor(workspaceEdit?: WorkspaceEdit);

      property edit

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

      method createFile

      createFile: {
      (uri: DocumentUri, options?: CreateFileOptions): void;
      (
      uri: string,
      annotation: string | ChangeAnnotation,
      options?: CreateFileOptions
      ): string;
      };

        method deleteFile

        deleteFile: {
        (uri: DocumentUri, options?: DeleteFileOptions): void;
        (
        uri: string,
        annotation: string | ChangeAnnotation,
        options?: DeleteFileOptions
        ): string;
        };

          method getTextEditChange

          getTextEditChange: {
          (textDocument: OptionalVersionedTextDocumentIdentifier): TextEditChange;
          (uri: string): TextEditChange;
          };

          method renameFile

          renameFile: {
          (
          oldUri: DocumentUri,
          newUri: DocumentUri,
          options?: RenameFileOptions
          ): void;
          (
          oldUri: string,
          newUri: string,
          annotation?: string | ChangeAnnotation,
          options?: RenameFileOptions
          ): string;
          };

            Interfaces

            interface AnnotatedTextEdit

            interface AnnotatedTextEdit extends TextEdit {}
            • A special text edit with an additional change annotation.

              3.16.0.

            property annotationId

            annotationId: ChangeAnnotationIdentifier;
            • The actual identifier of the change annotation

            interface BaseSymbolInformation

            interface BaseSymbolInformation {}
            • A base for all symbol information.

            property containerName

            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.

            property kind

            kind: SymbolKind;
            • The kind of this symbol.

            property name

            name: string;
            • The name of this symbol.

            property tags

            tags?: SymbolTag[];
            • Tags for this symbol.

              3.16.0

            interface CallHierarchyIncomingCall

            interface CallHierarchyIncomingCall {}
            • Represents an incoming call, e.g. a caller of a method or constructor.

              3.16.0

            property from

            from: CallHierarchyItem;
            • The item that makes the call.

            property fromRanges

            fromRanges: Range[];
            • The ranges at which the calls appear. This is relative to the caller denoted by .

            interface CallHierarchyItem

            interface CallHierarchyItem {}
            • Represents programming constructs like functions or constructors in the context of call hierarchy.

              3.16.0

            property data

            data?: LSPAny;
            • A data entry field that is preserved between a call hierarchy prepare and incoming calls or outgoing calls requests.

            property detail

            detail?: string;
            • More detail for this item, e.g. the signature of a function.

            property kind

            kind: SymbolKind;
            • The kind of this item.

            property name

            name: string;
            • The name of this item.

            property range

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

            property selectionRange

            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 .

            property tags

            tags?: SymbolTag[];
            • Tags for this item.

            property uri

            uri: DocumentUri;
            • The resource identifier of this item.

            interface CallHierarchyOutgoingCall

            interface CallHierarchyOutgoingCall {}
            • Represents an outgoing call, e.g. calling a getter from a method or a method from a constructor etc.

              3.16.0

            property fromRanges

            fromRanges: Range[];
            • The range at which this item is called. This is the range relative to the caller, e.g the item passed to and not .

            property to

            to: CallHierarchyItem;
            • The item that is called.

            interface ChangeAnnotation

            interface ChangeAnnotation {}
            • Additional information that describes document changes.

              3.16.0

            property description

            description?: string;
            • A human-readable string which is rendered less prominent in the user interface.

            property label

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

            property needsConfirmation

            needsConfirmation?: boolean;
            • A flag which indicates that user confirmation is needed before applying the change.

            interface CodeAction

            interface CodeAction {}
            • 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.

            property command

            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.

            property data

            data?: LSPAny;
            • A data entry field that is preserved on a code action between a textDocument/codeAction and a codeAction/resolve request.

              3.16.0

            property diagnostics

            diagnostics?: Diagnostic[];
            • The diagnostics that this code action resolves.

            property disabled

            disabled?: {
            /**
            * Human readable description of why the code action is currently disabled.
            *
            * This is displayed in the code actions UI.
            */
            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](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.

              3.16.0

            property edit

            edit?: WorkspaceEdit;
            • The workspace edit this code action performs.

            property isPreferred

            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.

              3.15.0

            property kind

            kind?: CodeActionKind;
            • The kind of the code action.

              Used to filter code actions.

            property title

            title: string;
            • A short, human-readable, title for this code action.

            interface CodeActionContext

            interface CodeActionContext {}
            • Contains additional diagnostic information about the context in which a is run.

            property diagnostics

            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.

            property only

            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.

            property triggerKind

            triggerKind?: CodeActionTriggerKind;
            • The reason why code actions were requested.

              3.17.0

            interface CodeDescription

            interface CodeDescription {}
            • Structure to capture a description for an error code.

              3.16.0

            property href

            href: URI;
            • An URI to open with more information about the diagnostic error.

            interface CodeLens

            interface CodeLens {}
            • A code lens represents a 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.

            property command

            command?: Command;
            • The command this code lens represents.

            property data

            data?: LSPAny;

            property range

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

            interface Color

            interface Color {}
            • Represents a color in RGBA space.

            property alpha

            readonly alpha: decimal;
            • The alpha component of this color in the range [0-1].

            property blue

            readonly blue: decimal;
            • The blue component of this color in the range [0-1].

            property green

            readonly green: decimal;
            • The green component of this color in the range [0-1].

            property red

            readonly red: decimal;
            • The red component of this color in the range [0-1].

            interface ColorInformation

            interface ColorInformation {}
            • Represents a color range from a document.

            property color

            color: Color;
            • The actual color value for this color range.

            property range

            range: Range;
            • The range in the document where this color appears.

            interface ColorPresentation

            interface ColorPresentation {}

              property additionalTextEdits

              additionalTextEdits?: TextEdit[];
              • An optional array of additional that are applied when selecting this color presentation. Edits must not overlap with the main nor with themselves.

              property label

              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.

              property textEdit

              textEdit?: TextEdit;
              • An which is applied to a document when selecting this presentation for the color. When falsy the is used.

              interface Command

              interface Command {}
              • 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.

              property arguments

              arguments?: LSPAny[];
              • Arguments that the command handler should be invoked with.

              property command

              command: string;
              • The identifier of the actual command handler.

              property title

              title: string;
              • Title of the command, like save.

              interface CompletionItem

              interface CompletionItem {}
              • A completion item represents a text snippet that is proposed to complete text that is being typed.

              property additionalTextEdits

              additionalTextEdits?: TextEdit[];
              • An optional array of additional that are applied when selecting this completion. Edits must not overlap (including the same insert position) with the main 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).

              property command

              command?: Command;
              • An optional that is executed *after* inserting this completion. *Note* that additional modifications to the current document should be described with the -property.

              property commitCharacters

              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.

              property data

              data?: LSPAny;

              property deprecated

              deprecated?: boolean;
              • Indicates if this item is deprecated.

                Deprecated

                Use tags instead.

              property detail

              detail?: string;
              • A human-readable string with additional information about this item, like type or symbol information.

              property documentation

              documentation?: string | MarkupContent;
              • A human-readable string that represents a doc-comment.

              property filterText

              filterText?: string;
              • A string that should be used when filtering a set of completion items. When falsy the is used.

              property insertText

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

              property insertTextFormat

              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.

              property insertTextMode

              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.

                3.16.0

              property kind

              kind?: CompletionItemKind;
              • The kind of this completion item. Based of the kind an icon is chosen by the editor.

              property label

              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.

              property labelDetails

              labelDetails?: CompletionItemLabelDetails;
              • Additional details for the label

                3.17.0

              property preselect

              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.

              property sortText

              sortText?: string;
              • A string that should be used when comparing this item with other items. When falsy the is used.

              property tags

              tags?: CompletionItemTag[];
              • Tags for this completion item.

                3.15.0

              property textEdit

              textEdit?: TextEdit | InsertReplaceEdit;
              • An which is applied to a document when selecting this completion. When an edit is provided the value of 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.

                3.16.0 additional type InsertReplaceEdit

              property textEditText

              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.

                3.17.0

              interface CompletionItemLabelDetails

              interface CompletionItemLabelDetails {}
              • Additional details for a completion item label.

                3.17.0

              property description

              description?: string;
              • An optional string which is rendered less prominently after CompletionItem.detail. Should be used for fully qualified names and file paths.

              property detail

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

              interface CompletionList

              interface CompletionList {}
              • Represents a collection of to be presented in the editor.

              property isIncomplete

              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.

              property itemDefaults

              itemDefaults?: {
              /**
              * A default commit character set.
              *
              * @since 3.17.0
              */
              commitCharacters?: string[];
              /**
              * A default edit range.
              *
              * @since 3.17.0
              */
              editRange?:
              | Range
              | {
              insert: Range;
              replace: Range;
              };
              /**
              * A default insert text format.
              *
              * @since 3.17.0
              */
              insertTextFormat?: InsertTextFormat;
              /**
              * A default insert text mode.
              *
              * @since 3.17.0
              */
              insertTextMode?: InsertTextMode;
              /**
              * A default data value.
              *
              * @since 3.17.0
              */
              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.

                3.17.0

              property items

              items: CompletionItem[];
              • The completion items.

              interface CreateFile

              interface CreateFile extends ResourceOperation {}
              • Create file operation.

              property kind

              kind: 'create';
              • A create

              property options

              options?: CreateFileOptions;
              • Additional options

              property uri

              uri: DocumentUri;
              • The resource to create.

              interface CreateFileOptions

              interface CreateFileOptions {}
              • Options to create a file.

              property ignoreIfExists

              ignoreIfExists?: boolean;
              • Ignore if exists.

              property overwrite

              overwrite?: boolean;
              • Overwrite existing file. Overwrite wins over ignoreIfExists

              interface DeleteFile

              interface DeleteFile extends ResourceOperation {}
              • Delete file operation

              property kind

              kind: 'delete';
              • A delete

              property options

              options?: DeleteFileOptions;
              • Delete options.

              property uri

              uri: DocumentUri;
              • The file to delete.

              interface DeleteFileOptions

              interface DeleteFileOptions {}
              • Delete file options

              property ignoreIfNotExists

              ignoreIfNotExists?: boolean;
              • Ignore the operation if the file doesn't exist.

              property recursive

              recursive?: boolean;
              • Delete the content recursively if a folder is denoted.

              interface Diagnostic

              interface Diagnostic {}
              • Represents a diagnostic, such as a compiler error or warning. Diagnostic objects are only valid in the scope of a resource.

              property code

              code?: integer | string;
              • The diagnostic's code, which usually appear in the user interface.

              property codeDescription

              codeDescription?: CodeDescription;
              • An optional property to describe the error code. Requires the code field (above) to be present/not null.

                3.16.0

              property data

              data?: LSPAny;
              • A data entry field that is preserved between a textDocument/publishDiagnostics notification and textDocument/codeAction request.

                3.16.0

              property message

              message: string;
              • The diagnostic's message. It usually appears in the user interface

              property range

              range: Range;
              • The range at which the message applies

              property relatedInformation

              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.

              property severity

              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.

              property source

              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.

              property tags

              tags?: DiagnosticTag[];
              • Additional metadata about the diagnostic.

                3.15.0

              interface DiagnosticRelatedInformation

              interface DiagnosticRelatedInformation {}
              • 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.

              property location

              location: Location;
              • The location of this related diagnostic information.

              property message

              message: string;
              • The message of this related diagnostic information.

              interface DocumentHighlight

              interface DocumentHighlight {}
              • 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.

              property kind

              kind?: DocumentHighlightKind;
              • The highlight kind, default is .

              property range

              range: Range;
              • The range this highlight applies to.

              interface DocumentLink {}
              • A document link is a range in a text document that links to an internal or external resource, like another text document or a web site.

              property data

              data?: LSPAny;
              • A data entry field that is preserved on a document link between a DocumentLinkRequest and a DocumentLinkResolveRequest.

              property range

              range: Range;
              • The range this link applies to.

              property target

              target?: URI;
              • The uri this link points to. If missing a resolve request is sent later.

              property tooltip

              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.

                3.15.0

              interface DocumentSymbol

              interface DocumentSymbol {}
              • 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.

              property children

              children?: DocumentSymbol[];
              • Children of this symbol, e.g. properties of a class.

              property deprecated

              deprecated?: boolean;
              • Indicates if this symbol is deprecated.

                Deprecated

                Use tags instead

              property detail

              detail?: string;
              • More detail for this symbol, e.g the signature of a function.

              property kind

              kind: SymbolKind;
              • The kind of this symbol.

              property name

              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.

              property range

              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.

              property selectionRange

              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.

              property tags

              tags?: SymbolTag[];
              • Tags for this document symbol.

                3.16.0

              interface FoldingRange

              interface FoldingRange {}
              • 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.

              property collapsedText

              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.

                3.17.0

              property endCharacter

              endCharacter?: uinteger;
              • The zero-based character offset before the folded range ends. If not defined, defaults to the length of the end line.

              property endLine

              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.

              property kind

              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.

              property startCharacter

              startCharacter?: uinteger;
              • The zero-based character offset from where the folded range starts. If not defined, defaults to the length of the start line.

              property startLine

              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.

              interface FormattingOptions

              interface FormattingOptions {}
              • Value-object describing what options formatting should use.

              property insertFinalNewline

              insertFinalNewline?: boolean;
              • Insert a newline character at the end of the file if one does not exist.

                3.15.0

              property insertSpaces

              insertSpaces: boolean;
              • Prefer spaces over tabs.

              property tabSize

              tabSize: uinteger;
              • Size of a tab in spaces.

              property trimFinalNewlines

              trimFinalNewlines?: boolean;
              • Trim all newlines after the final newline at the end of the file.

                3.15.0

              property trimTrailingWhitespace

              trimTrailingWhitespace?: boolean;
              • Trim trailing whitespace on a line.

                3.15.0

              index signature

              [key: string]: boolean | integer | string | undefined;
              • Signature for further properties.

              interface Hover

              interface Hover {}
              • The result of a hover request.

              property contents

              contents: MarkupContent | MarkedString | MarkedString[];
              • The hover's content

              property range

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

              interface InlineCompletionContext

              interface InlineCompletionContext {}
              • Provides information about the context in which an inline completion was requested.

                3.18.0

              property selectedCompletionInfo

              selectedCompletionInfo?: SelectedCompletionInfo;
              • Provides information about the currently selected item in the autocomplete widget if it is visible.

              property triggerKind

              triggerKind: InlineCompletionTriggerKind;
              • Describes how the inline completion was triggered.

              interface InlineCompletionItem

              interface InlineCompletionItem {}
              • An inline completion item represents a text snippet that is proposed inline to complete text that is being typed.

                3.18.0

              property command

              command?: Command;
              • An optional Command that is executed *after* inserting this completion.

              property filterText

              filterText?: string;

              property insertText

              insertText: string | StringValue;
              • The text to replace the range with. Must be set.

              property range

              range?: Range;
              • The range to replace. Must begin and end on the same line.

              interface InlineCompletionList

              interface InlineCompletionList {}
              • Represents a collection of to be presented in the editor.

                3.18.0

              property items

              items: InlineCompletionItem[];
              • The inline completion items

              interface InsertReplaceEdit

              interface InsertReplaceEdit {}
              • A special text edit to provide an insert and a replace operation.

                3.16.0

              property insert

              insert: Range;
              • The range if the insert is requested

              property newText

              newText: string;
              • The string to be inserted.

              property replace

              replace: Range;
              • The range if the replace is requested.

              interface Location

              interface Location {}
              • Represents a location inside a resource, such as a line inside a text file.

              property range

              range: Range;

                property uri

                uri: DocumentUri;
                  interface LocationLink {}
                  • Represents the connection of two locations. Provides additional metadata over normal , including an origin range.

                  property originSelectionRange

                  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.

                  property targetRange

                  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.

                  property targetSelectionRange

                  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

                  property targetUri

                  targetUri: DocumentUri;
                  • The target resource identifier of this link.

                  interface MarkupContent

                  interface MarkupContent {}
                  • 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:

                    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.

                  property kind

                  kind: MarkupKind;
                  • The type of the Markup

                  property value

                  value: string;
                  • The content itself

                  interface OptionalVersionedTextDocumentIdentifier

                  interface OptionalVersionedTextDocumentIdentifier extends TextDocumentIdentifier {}
                  • A text document identifier to optionally denote a specific version of a text document.

                  property version

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

                  interface ParameterInformation

                  interface ParameterInformation {}
                  • Represents a parameter of a callable-signature. A parameter can have a label and a doc-comment.

                  property documentation

                  documentation?: string | MarkupContent;
                  • The human-readable doc-comment of this parameter. Will be shown in the UI but can be omitted.

                  property label

                  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.

                  interface Position

                  interface Position {}
                  • 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.

                    3.17.0 - support for negotiated position encoding.

                  property character

                  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.

                  property line

                  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.

                  interface Range

                  interface Range {}
                  • 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:

                    {
                    start: { line: 5, character: 23 }
                    end : { line 6, character : 0 }
                    }

                  property end

                  end: Position;
                  • The range's end position.

                  property start

                  start: Position;
                  • The range's start position.

                  interface ReferenceContext

                  interface ReferenceContext {}
                  • Value-object that contains additional information when requesting references.

                  property includeDeclaration

                  includeDeclaration: boolean;
                  • Include the declaration of the current symbol.

                  interface RenameFile

                  interface RenameFile extends ResourceOperation {}
                  • Rename file operation

                  property kind

                  kind: 'rename';
                  • A rename

                  property newUri

                  newUri: DocumentUri;
                  • The new location.

                  property oldUri

                  oldUri: DocumentUri;
                  • The old (existing) location.

                  property options

                  options?: RenameFileOptions;
                  • Rename options.

                  interface RenameFileOptions

                  interface RenameFileOptions {}
                  • Rename file options

                  property ignoreIfExists

                  ignoreIfExists?: boolean;
                  • Ignores if target exists.

                  property overwrite

                  overwrite?: boolean;
                  • Overwrite target if existing. Overwrite wins over ignoreIfExists

                  interface SelectedCompletionInfo

                  interface SelectedCompletionInfo {}
                  • Describes the currently selected completion item.

                    3.18.0

                  property range

                  range: Range;
                  • The range that will be replaced if this completion item is accepted.

                  property text

                  text: string;
                  • The text the range will be replaced with if this completion is accepted.

                  interface SelectionRange

                  interface SelectionRange {}
                  • A selection range represents a part of a selection hierarchy. A selection range may have a parent selection range that contains it.

                  property parent

                  parent?: SelectionRange;
                  • The parent selection range containing this range. Therefore parent.range must contain this.range.

                  property range

                  range: Range;
                  • The of this selection range.

                  interface SemanticTokens

                  interface SemanticTokens {}
                  • 3.16.0

                  property data

                  data: uinteger[];
                  • The actual tokens.

                  property resultId

                  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.

                  interface SemanticTokensDelta

                  interface SemanticTokensDelta {}
                  • 3.16.0

                  property edits

                  edits: SemanticTokensEdit[];
                  • The semantic token edits to transform a previous result into a new result.

                  property resultId

                  readonly resultId?: string;

                    interface SemanticTokensEdit

                    interface SemanticTokensEdit {}
                    • 3.16.0

                    property data

                    data?: uinteger[];
                    • The elements to insert.

                    property deleteCount

                    deleteCount: uinteger;
                    • The count of elements to remove.

                    property start

                    start: uinteger;
                    • The start offset of the edit.

                    interface SemanticTokensLegend

                    interface SemanticTokensLegend {}
                    • 3.16.0

                    property tokenModifiers

                    tokenModifiers: string[];
                    • The token modifiers a server uses.

                    property tokenTypes

                    tokenTypes: string[];
                    • The token types a server uses.

                    interface SignatureHelp

                    interface SignatureHelp {}
                    • Signature help represents the signature of something callable. There can be multiple signature but only one active and only one active parameter.

                    property activeParameter

                    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.

                    property activeSignature

                    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.

                    property signatures

                    signatures: SignatureInformation[];
                    • One or more signatures.

                    interface SignatureInformation

                    interface SignatureInformation {}
                    • Represents the signature of something callable. A signature can have a label, like a function-name, a doc-comment, and a set of parameters.

                    property activeParameter

                    activeParameter?: uinteger;
                    • The index of the active parameter.

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

                      3.16.0

                    property documentation

                    documentation?: string | MarkupContent;
                    • The human-readable doc-comment of this signature. Will be shown in the UI but can be omitted.

                    property label

                    label: string;
                    • The label of this signature. Will be shown in the UI.

                    property parameters

                    parameters?: ParameterInformation[];
                    • The parameters of this signature.

                    interface StringValue

                    interface StringValue {}
                    • 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}.

                      3.18.0

                    property kind

                    kind: 'snippet';
                    • The kind of string value.

                    property value

                    value: string;
                    • The snippet string.

                    interface SymbolInformation

                    interface SymbolInformation extends BaseSymbolInformation {}
                    • Represents information about programming constructs like variables, classes, interfaces etc.

                    property deprecated

                    deprecated?: boolean;
                    • Indicates if this symbol is deprecated.

                      Deprecated

                      Use tags instead

                    property location

                    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.

                    interface TextDocument

                    interface TextDocument {}
                    • A simple text document. Not to be implemented. The document keeps the content as string.

                      Deprecated

                      Use the text document from the new vscode-languageserver-textdocument package.

                    property languageId

                    readonly languageId: string;
                    • The identifier of the language associated with this document.

                      Modifiers

                      • @readonly

                    property lineCount

                    readonly lineCount: uinteger;
                    • The number of lines in this document.

                      Modifiers

                      • @readonly

                    property uri

                    readonly uri: DocumentUri;
                    • The associated URI for this document. Most documents have the __file__-scheme, indicating that they represent files on disk. However, some documents may have other schemes indicating that they are not available on disk.

                      Modifiers

                      • @readonly

                    property version

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

                      Modifiers

                      • @readonly

                    method getText

                    getText: (range?: Range) => string;
                    • Get the text of this document. A substring can be retrieved by providing a range.

                      Parameter range

                      (optional) An range within the document to return. If no range is passed, the full content is returned. Invalid range positions are adjusted as described in and . If the start range position is greater than the end range position, then the effect of getText is as if the two positions were swapped.

                      The text of this document or a substring of the text if a range is provided.

                    method offsetAt

                    offsetAt: (position: Position) => uinteger;
                    • Converts the position to a zero-based offset. Invalid positions are adjusted as described in and .

                      Parameter position

                      A position. A valid zero-based offset.

                    method positionAt

                    positionAt: (offset: uinteger) => Position;
                    • Converts a zero-based offset to a position.

                      Parameter offset

                      A zero-based offset. A valid .

                    interface TextDocumentEdit

                    interface TextDocumentEdit {}
                    • 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.

                    property edits

                    edits: (TextEdit | AnnotatedTextEdit)[];
                    • The edits to be applied.

                      3.16.0 - support for AnnotatedTextEdit. This is guarded using a client capability.

                    property textDocument

                    textDocument: OptionalVersionedTextDocumentIdentifier;
                    • The text document to change.

                    interface TextDocumentIdentifier

                    interface TextDocumentIdentifier {}
                    • A literal to identify a text document in the client.

                    property uri

                    uri: DocumentUri;
                    • The text document's uri.

                    interface TextDocumentItem

                    interface TextDocumentItem {}
                    • An item to transfer a text document from the client to the server.

                    property languageId

                    languageId: string;
                    • The text document's language identifier.

                    property text

                    text: string;
                    • The content of the opened text document.

                    property uri

                    uri: DocumentUri;
                    • The text document's uri.

                    property version

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

                    interface TextEdit

                    interface TextEdit {}
                    • A text edit applicable to a text document.

                    property newText

                    newText: string;
                    • The string to be inserted. For delete operations use an empty string.

                    property range

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

                    interface TextEditChange

                    interface TextEditChange {}
                    • A change to capture text edits for existing resources.

                    method add

                    add: (edit: TextEdit | AnnotatedTextEdit) => void;
                    • Adds a text edit.

                      Parameter edit

                      the text edit to add.

                      3.16.0 - support for annotated text edits. This is usually guarded using a client capability.

                    method all

                    all: () => (TextEdit | AnnotatedTextEdit)[];
                    • Gets all text edits for this change.

                      An array of text edits.

                      3.16.0 - support for annotated text edits. This is usually guarded using a client capability.

                    method clear

                    clear: () => void;
                    • Clears the edits for this change.

                    method delete

                    delete: {
                    (range: Range): void;
                    (range: Range, annotation?: string | ChangeAnnotation): string;
                    };
                    • Delete the text at the given range.

                      Parameter range

                      A range.

                      Parameter annotation

                      An optional annotation.

                    method insert

                    insert: {
                    (position: Position, newText: string): void;
                    (
                    position: Position,
                    newText: string,
                    annotation: string | ChangeAnnotation
                    ): string;
                    };
                    • Insert the given text at the given position.

                      Parameter position

                      A position.

                      Parameter newText

                      A string.

                      Parameter annotation

                      An optional annotation.

                    method replace

                    replace: {
                    (range: Range, newText: string): void;
                    (
                    range: Range,
                    newText: string,
                    annotation?: string | ChangeAnnotation
                    ): string;
                    };
                    • Replace the given range with given text for the given resource.

                      Parameter range

                      A range.

                      Parameter newText

                      A string.

                      Parameter annotation

                      An optional annotation.

                    interface VersionedTextDocumentIdentifier

                    interface VersionedTextDocumentIdentifier extends TextDocumentIdentifier {}
                    • A text document identifier to denote a specific version of a text document.

                    property version

                    version: integer;
                    • The version number of this document.

                    interface WorkspaceEdit

                    interface WorkspaceEdit {}
                    • 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

                    property changeAnnotations

                    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.

                      3.16.0

                    property changes

                    changes?: {
                    [uri: DocumentUri]: TextEdit[];
                    };
                    • Holds changes to existing resources.

                    property documentChanges

                    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.

                    interface WorkspaceFolder

                    interface WorkspaceFolder {}
                    • A workspace folder inside a client.

                    property name

                    name: string;
                    • The name of the workspace folder. Used to refer to this workspace folder in the user interface.

                    property uri

                    uri: URI;
                    • The associated URI for this workspace folder.

                    interface WorkspaceSymbol

                    interface WorkspaceSymbol extends BaseSymbolInformation {}
                    • A special workspace symbol that supports locations without a range.

                      See also SymbolInformation.

                      3.17.0

                    property data

                    data?: LSPAny;
                    • A data entry field that is preserved on a workspace symbol between a workspace symbol request and a workspace symbol resolve request.

                    property location

                    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.

                    Enums

                    enum SemanticTokenModifiers

                    enum SemanticTokenModifiers {
                    declaration = 'declaration',
                    definition = 'definition',
                    readonly = 'readonly',
                    static = 'static',
                    deprecated = 'deprecated',
                    abstract = 'abstract',
                    async = 'async',
                    modification = 'modification',
                    documentation = 'documentation',
                    defaultLibrary = 'defaultLibrary',
                    }
                    • A set of predefined token modifiers. This set is not fixed an clients can specify additional token types via the corresponding client capabilities.

                      3.16.0

                    member abstract

                    abstract = 'abstract'

                      member async

                      async = 'async'

                        member declaration

                        declaration = 'declaration'

                          member defaultLibrary

                          defaultLibrary = 'defaultLibrary'

                            member definition

                            definition = 'definition'

                              member deprecated

                              deprecated = 'deprecated'

                                member documentation

                                documentation = 'documentation'

                                  member modification

                                  modification = 'modification'

                                    member readonly

                                    readonly = 'readonly'

                                      member static

                                      static = 'static'

                                        enum SemanticTokenTypes

                                        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',
                                        }
                                        • A set of predefined token types. This set is not fixed an clients can specify additional token types via the corresponding client capabilities.

                                          3.16.0

                                        member class

                                        class = 'class'

                                          member comment

                                          comment = 'comment'

                                            member decorator

                                            decorator = 'decorator'
                                            • 3.17.0

                                            member enum

                                            enum = 'enum'

                                              member enumMember

                                              enumMember = 'enumMember'

                                                member event

                                                event = 'event'

                                                  member function

                                                  function = 'function'

                                                    member interface

                                                    interface = 'interface'

                                                      member keyword

                                                      keyword = 'keyword'

                                                        member macro

                                                        macro = 'macro'

                                                          member method

                                                          method = 'method'

                                                            member modifier

                                                            modifier = 'modifier'

                                                              member namespace

                                                              namespace = 'namespace'

                                                                member number

                                                                number = 'number'

                                                                  member operator

                                                                  operator = 'operator'

                                                                    member parameter

                                                                    parameter = 'parameter'

                                                                      member property

                                                                      property = 'property'

                                                                        member regexp

                                                                        regexp = 'regexp'

                                                                          member string

                                                                          string = 'string'

                                                                            member struct

                                                                            struct = 'struct'

                                                                              member type

                                                                              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.

                                                                              member typeParameter

                                                                              typeParameter = 'typeParameter'

                                                                                member variable

                                                                                variable = 'variable'

                                                                                  Type Aliases

                                                                                  type ChangeAnnotationIdentifier

                                                                                  type ChangeAnnotationIdentifier = string;
                                                                                  • An identifier to refer to a change annotation stored with a workspace edit.

                                                                                  type CodeActionKind

                                                                                  type CodeActionKind = string;
                                                                                  • The kind of a code action.

                                                                                    Kinds are a hierarchical list of identifiers separated by ., e.g. "refactor.extract.function".

                                                                                    The set of kinds is open and client needs to announce the kinds it supports to the server during initialization.

                                                                                  type CodeActionTriggerKind

                                                                                  type CodeActionTriggerKind = 1 | 2;

                                                                                    type CompletionItemKind

                                                                                    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;

                                                                                      type CompletionItemTag

                                                                                      type CompletionItemTag = 1;

                                                                                        type decimal

                                                                                        type decimal = number;
                                                                                        • Defines a decimal number. Since decimal numbers are very rare in the language server specification we denote the exact range with every decimal using the mathematics interval notations (e.g. [0, 1] denotes all decimals d with 0 <= d <= 1.

                                                                                        type Declaration

                                                                                        type Declaration = Location | Location[];
                                                                                        • The declaration of a symbol representation as one or many .

                                                                                        type DeclarationLink = LocationLink;
                                                                                        • Information about where a symbol is declared.

                                                                                          Provides additional metadata over normal declarations, including the range of the declaring symbol.

                                                                                          Servers should prefer returning DeclarationLink over Declaration if supported by the client.

                                                                                        type Definition

                                                                                        type Definition = Location | Location[];
                                                                                        • The definition of a symbol represented as one or many . 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.

                                                                                        type DefinitionLink = LocationLink;
                                                                                        • Information about where a symbol is defined.

                                                                                          Provides additional metadata over normal definitions, including the range of the defining symbol

                                                                                        type DiagnosticSeverity

                                                                                        type DiagnosticSeverity = 1 | 2 | 3 | 4;

                                                                                          type DiagnosticTag

                                                                                          type DiagnosticTag = 1 | 2;

                                                                                            type DocumentHighlightKind

                                                                                            type DocumentHighlightKind = 1 | 2 | 3;

                                                                                              type DocumentUri

                                                                                              type DocumentUri = string;
                                                                                              • A tagging type for string properties that are actually document URIs.

                                                                                              type FoldingRangeKind

                                                                                              type FoldingRangeKind = string;
                                                                                              • A predefined folding range kind.

                                                                                                The type is a string since the value set is extensible

                                                                                              type InlayHint

                                                                                              type InlayHint = {
                                                                                              /**
                                                                                              * The position of this hint.
                                                                                              */
                                                                                              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;
                                                                                              /**
                                                                                              * 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[];
                                                                                              /**
                                                                                              * The tooltip text when you hover over this item.
                                                                                              */
                                                                                              tooltip?: string | MarkupContent;
                                                                                              /**
                                                                                              * 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;
                                                                                              /**
                                                                                              * 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;
                                                                                              /**
                                                                                              * A data entry field that is preserved on an inlay hint between
                                                                                              * a `textDocument/inlayHint` and a `inlayHint/resolve` request.
                                                                                              */
                                                                                              data?: LSPAny;
                                                                                              };
                                                                                              • Inlay hint information.

                                                                                                3.17.0

                                                                                              type InlayHintKind

                                                                                              type InlayHintKind = 1 | 2;

                                                                                                type InlayHintLabelPart

                                                                                                type 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;
                                                                                                /**
                                                                                                * 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;
                                                                                                /**
                                                                                                * 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;
                                                                                                };
                                                                                                • An inlay hint label part allows for interactive and composite labels of inlay hints.

                                                                                                  3.17.0

                                                                                                type InlineCompletionTriggerKind

                                                                                                type InlineCompletionTriggerKind = 0 | 1;

                                                                                                  type InlineValue

                                                                                                  type InlineValue =
                                                                                                  | InlineValueText
                                                                                                  | InlineValueVariableLookup
                                                                                                  | InlineValueEvaluatableExpression;
                                                                                                  • Inline value information can be provided by different means: - directly as a text value (class InlineValueText). - as a name to use for a variable lookup (class InlineValueVariableLookup) - as an evaluatable expression (class InlineValueEvaluatableExpression) The InlineValue types combines all inline value types into one type.

                                                                                                    3.17.0

                                                                                                  type InlineValueContext

                                                                                                  type InlineValueContext = {
                                                                                                  /**
                                                                                                  * The stack frame (as a DAP Id) where the execution has stopped.
                                                                                                  */
                                                                                                  frameId: integer;
                                                                                                  /**
                                                                                                  * The document range where execution has stopped.
                                                                                                  * Typically the end position of the range denotes the line where the inline values are shown.
                                                                                                  */
                                                                                                  stoppedLocation: Range;
                                                                                                  };
                                                                                                  • 3.17.0

                                                                                                  type InlineValueEvaluatableExpression

                                                                                                  type InlineValueEvaluatableExpression = {
                                                                                                  /**
                                                                                                  * The document range for which the inline value applies.
                                                                                                  * The range is used to extract the evaluatable expression from the underlying document.
                                                                                                  */
                                                                                                  range: Range;
                                                                                                  /**
                                                                                                  * If specified the expression overrides the extracted expression.
                                                                                                  */
                                                                                                  expression?: string;
                                                                                                  };
                                                                                                  • Provide an inline value through an expression evaluation. If only a range is specified, the expression will be extracted from the underlying document. An optional expression can be used to override the extracted expression.

                                                                                                    3.17.0

                                                                                                  type InlineValueText

                                                                                                  type InlineValueText = {
                                                                                                  /**
                                                                                                  * The document range for which the inline value applies.
                                                                                                  */
                                                                                                  range: Range;
                                                                                                  /**
                                                                                                  * The text of the inline value.
                                                                                                  */
                                                                                                  text: string;
                                                                                                  };
                                                                                                  • Provide inline value as text.

                                                                                                    3.17.0

                                                                                                  type InlineValueVariableLookup

                                                                                                  type InlineValueVariableLookup = {
                                                                                                  /**
                                                                                                  * The document range for which the inline value applies.
                                                                                                  * The range is used to extract the variable name from the underlying document.
                                                                                                  */
                                                                                                  range: Range;
                                                                                                  /**
                                                                                                  * If specified the name of the variable to look up.
                                                                                                  */
                                                                                                  variableName?: string;
                                                                                                  /**
                                                                                                  * How to perform the lookup.
                                                                                                  */
                                                                                                  caseSensitiveLookup: boolean;
                                                                                                  };
                                                                                                  • Provide inline value through a variable lookup. If only a range is specified, the variable name will be extracted from the underlying document. An optional variable name can be used to override the extracted name.

                                                                                                    3.17.0

                                                                                                  type InsertTextFormat

                                                                                                  type InsertTextFormat = 1 | 2;

                                                                                                    type InsertTextMode

                                                                                                    type InsertTextMode = 1 | 2;

                                                                                                      type integer

                                                                                                      type integer = number;
                                                                                                      • Defines an integer in the range of -2^31 to 2^31 - 1.

                                                                                                      type LSPAny

                                                                                                      type LSPAny = any;
                                                                                                      • The LSP any type.

                                                                                                        In the current implementation we map LSPAny to any. This is due to the fact that the TypeScript compilers can't infer string access signatures for interface correctly (it can though for types). See the following issue for details: https://github.com/microsoft/TypeScript/issues/15300.

                                                                                                        When the issue is addressed LSPAny can be defined as follows:

                                                                                                        export type LSPAny = LSPObject | LSPArray | string | integer | uinteger | decimal | boolean | null | undefined;
                                                                                                        export type LSPObject = { [key: string]: LSPAny };
                                                                                                        export type LSPArray = LSPAny[];

                                                                                                        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.

                                                                                                        3.17.0

                                                                                                      type LSPArray

                                                                                                      type LSPArray = any[];

                                                                                                        type LSPObject

                                                                                                        type LSPObject = object;

                                                                                                          type MarkedString

                                                                                                          type MarkedString =
                                                                                                          | string
                                                                                                          | {
                                                                                                          language: string;
                                                                                                          value: string;
                                                                                                          };
                                                                                                          • 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:

                                                                                                            ${value}

                                                                                                            Note that markdown strings will be sanitized - that means html will be escaped.

                                                                                                            Deprecated

                                                                                                            use MarkupContent instead.

                                                                                                          type MarkupKind

                                                                                                          type MarkupKind = 'plaintext' | 'markdown';

                                                                                                            type SymbolKind

                                                                                                            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;

                                                                                                              type SymbolTag

                                                                                                              type SymbolTag = 1;

                                                                                                                type TypeHierarchyItem

                                                                                                                type TypeHierarchyItem = {
                                                                                                                /**
                                                                                                                * The name of this item.
                                                                                                                */
                                                                                                                name: string;
                                                                                                                /**
                                                                                                                * The kind of this item.
                                                                                                                */
                                                                                                                kind: SymbolKind;
                                                                                                                /**
                                                                                                                * Tags for this item.
                                                                                                                */
                                                                                                                tags?: SymbolTag[];
                                                                                                                /**
                                                                                                                * More detail for this item, e.g. the signature of a function.
                                                                                                                */
                                                                                                                detail?: string;
                                                                                                                /**
                                                                                                                * 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 TypeHierarchyItem.range `range`}.
                                                                                                                */
                                                                                                                selectionRange: Range;
                                                                                                                /**
                                                                                                                * A data entry field that is preserved between a type hierarchy prepare and
                                                                                                                * supertypes or subtypes requests. It could also be used to identify the
                                                                                                                * type hierarchy in the server, helping improve the performance on
                                                                                                                * resolving supertypes and subtypes.
                                                                                                                */
                                                                                                                data?: LSPAny;
                                                                                                                };
                                                                                                                • 3.17.0

                                                                                                                type uinteger

                                                                                                                type uinteger = number;
                                                                                                                • Defines an unsigned integer in the range of 0 to 2^31 - 1.

                                                                                                                type URI

                                                                                                                type URI = string;
                                                                                                                • A tagging type for string properties that are actually URIs

                                                                                                                  3.16.0

                                                                                                                Namespaces

                                                                                                                namespace AnnotatedTextEdit

                                                                                                                namespace AnnotatedTextEdit {}

                                                                                                                  function del

                                                                                                                  del: (range: Range, annotation: ChangeAnnotationIdentifier) => AnnotatedTextEdit;
                                                                                                                  • Creates an annotated delete text edit.

                                                                                                                    Parameter range

                                                                                                                    The range of text to be deleted.

                                                                                                                    Parameter annotation

                                                                                                                    The annotation.

                                                                                                                  function insert

                                                                                                                  insert: (
                                                                                                                  position: Position,
                                                                                                                  newText: string,
                                                                                                                  annotation: ChangeAnnotationIdentifier
                                                                                                                  ) => AnnotatedTextEdit;
                                                                                                                  • Creates an annotated insert text edit.

                                                                                                                    Parameter position

                                                                                                                    The position to insert the text at.

                                                                                                                    Parameter newText

                                                                                                                    The text to be inserted.

                                                                                                                    Parameter annotation

                                                                                                                    The annotation.

                                                                                                                  function is

                                                                                                                  is: (value: any) => value is AnnotatedTextEdit;

                                                                                                                    function replace

                                                                                                                    replace: (
                                                                                                                    range: Range,
                                                                                                                    newText: string,
                                                                                                                    annotation: ChangeAnnotationIdentifier
                                                                                                                    ) => AnnotatedTextEdit;
                                                                                                                    • Creates an annotated replace text edit.

                                                                                                                      Parameter range

                                                                                                                      The range of text to be replaced.

                                                                                                                      Parameter newText

                                                                                                                      The new text.

                                                                                                                      Parameter annotation

                                                                                                                      The annotation.

                                                                                                                    namespace ChangeAnnotation

                                                                                                                    namespace ChangeAnnotation {}

                                                                                                                      function create

                                                                                                                      create: (
                                                                                                                      label: string,
                                                                                                                      needsConfirmation?: boolean,
                                                                                                                      description?: string
                                                                                                                      ) => ChangeAnnotation;

                                                                                                                        function is

                                                                                                                        is: (value: any) => value is ChangeAnnotation;

                                                                                                                          namespace ChangeAnnotationIdentifier

                                                                                                                          namespace ChangeAnnotationIdentifier {}

                                                                                                                            function is

                                                                                                                            is: (value: any) => value is string;

                                                                                                                              namespace CodeAction

                                                                                                                              namespace CodeAction {}

                                                                                                                                function create

                                                                                                                                create: {
                                                                                                                                (title: string, kind?: CodeActionKind): CodeAction;
                                                                                                                                (title: string, command: Command, kind?: string): CodeAction;
                                                                                                                                (title: string, edit: WorkspaceEdit, kind?: string): CodeAction;
                                                                                                                                };
                                                                                                                                • Creates a new code action.

                                                                                                                                  Parameter title

                                                                                                                                  The title of the code action.

                                                                                                                                  Parameter kind

                                                                                                                                  The kind of the code action.

                                                                                                                                • Creates a new code action.

                                                                                                                                  Parameter title

                                                                                                                                  The title of the code action.

                                                                                                                                  Parameter command

                                                                                                                                  The command to execute.

                                                                                                                                  Parameter kind

                                                                                                                                  The kind of the code action.

                                                                                                                                • Creates a new code action.

                                                                                                                                  Parameter title

                                                                                                                                  The title of the code action.

                                                                                                                                  Parameter edit

                                                                                                                                  The edit to perform.

                                                                                                                                  Parameter kind

                                                                                                                                  The kind of the code action.

                                                                                                                                function is

                                                                                                                                is: (value: any) => value is CodeAction;

                                                                                                                                  namespace CodeActionContext

                                                                                                                                  namespace CodeActionContext {}
                                                                                                                                  • The CodeActionContext namespace provides helper functions to work with CodeActionContext literals.

                                                                                                                                  function create

                                                                                                                                  create: (
                                                                                                                                  diagnostics: Diagnostic[],
                                                                                                                                  only?: CodeActionKind[],
                                                                                                                                  triggerKind?: CodeActionTriggerKind
                                                                                                                                  ) => CodeActionContext;
                                                                                                                                  • Creates a new CodeActionContext literal.

                                                                                                                                  function is

                                                                                                                                  is: (value: any) => value is CodeActionContext;

                                                                                                                                  namespace CodeActionKind

                                                                                                                                  namespace CodeActionKind {}
                                                                                                                                  • A set of predefined code action kinds

                                                                                                                                  variable Empty

                                                                                                                                  const Empty: string;
                                                                                                                                  • Empty kind.

                                                                                                                                  variable QuickFix

                                                                                                                                  const QuickFix: string;
                                                                                                                                  • Base kind for quickfix actions: 'quickfix'

                                                                                                                                  variable Refactor

                                                                                                                                  const Refactor: string;
                                                                                                                                  • Base kind for refactoring actions: 'refactor'

                                                                                                                                  variable RefactorExtract

                                                                                                                                  const RefactorExtract: string;
                                                                                                                                  • Base kind for refactoring extraction actions: 'refactor.extract'

                                                                                                                                    Example extract actions:

                                                                                                                                    - Extract method - Extract function - Extract variable - Extract interface from class - ...

                                                                                                                                  variable RefactorInline

                                                                                                                                  const RefactorInline: string;
                                                                                                                                  • Base kind for refactoring inline actions: 'refactor.inline'

                                                                                                                                    Example inline actions:

                                                                                                                                    - Inline function - Inline variable - Inline constant - ...

                                                                                                                                  variable RefactorRewrite

                                                                                                                                  const RefactorRewrite: string;
                                                                                                                                  • Base kind for refactoring rewrite actions: 'refactor.rewrite'

                                                                                                                                    Example rewrite actions:

                                                                                                                                    - Convert JavaScript function to class - Add or remove parameter - Encapsulate field - Make method static - Move method to base class - ...

                                                                                                                                  variable Source

                                                                                                                                  const Source: string;
                                                                                                                                  • Base kind for source actions: source

                                                                                                                                    Source code actions apply to the entire file.

                                                                                                                                  variable SourceFixAll

                                                                                                                                  const SourceFixAll: string;
                                                                                                                                  • Base kind for auto-fix source actions: source.fixAll.

                                                                                                                                    Fix all actions automatically fix errors that have a clear fix that do not require user input. They should not suppress errors or perform unsafe fixes such as generating new types or classes.

                                                                                                                                    3.15.0

                                                                                                                                  variable SourceOrganizeImports

                                                                                                                                  const SourceOrganizeImports: string;
                                                                                                                                  • Base kind for an organize imports source action: source.organizeImports

                                                                                                                                  namespace CodeActionTriggerKind

                                                                                                                                  namespace CodeActionTriggerKind {}
                                                                                                                                  • The reason why code actions were requested.

                                                                                                                                    3.17.0

                                                                                                                                  variable Automatic

                                                                                                                                  const Automatic: number;
                                                                                                                                  • Code actions were requested automatically.

                                                                                                                                    This typically happens when current selection in a file changes, but can also be triggered when file content changes.

                                                                                                                                  variable Invoked

                                                                                                                                  const Invoked: number;
                                                                                                                                  • Code actions were explicitly requested by the user or by an extension.

                                                                                                                                  namespace CodeDescription

                                                                                                                                  namespace CodeDescription {}
                                                                                                                                  • The CodeDescription namespace provides functions to deal with descriptions for diagnostic codes.

                                                                                                                                    3.16.0

                                                                                                                                  function is

                                                                                                                                  is: (value: any) => value is CodeDescription;

                                                                                                                                    namespace CodeLens

                                                                                                                                    namespace CodeLens {}
                                                                                                                                    • The CodeLens namespace provides helper functions to work with CodeLens literals.

                                                                                                                                    function create

                                                                                                                                    create: (range: Range, data?: LSPAny) => CodeLens;
                                                                                                                                    • Creates a new CodeLens literal.

                                                                                                                                    function is

                                                                                                                                    is: (value: any) => value is CodeLens;
                                                                                                                                    • Checks whether the given literal conforms to the CodeLens interface.

                                                                                                                                    namespace Color

                                                                                                                                    namespace Color {}
                                                                                                                                    • The Color namespace provides helper functions to work with Color literals.

                                                                                                                                    function create

                                                                                                                                    create: (red: decimal, green: decimal, blue: decimal, alpha: decimal) => Color;
                                                                                                                                    • Creates a new Color literal.

                                                                                                                                    function is

                                                                                                                                    is: (value: any) => value is Color;
                                                                                                                                    • Checks whether the given literal conforms to the Color interface.

                                                                                                                                    namespace ColorInformation

                                                                                                                                    namespace ColorInformation {}
                                                                                                                                    • The ColorInformation namespace provides helper functions to work with ColorInformation literals.

                                                                                                                                    function create

                                                                                                                                    create: (range: Range, color: Color) => ColorInformation;
                                                                                                                                    • Creates a new ColorInformation literal.

                                                                                                                                    function is

                                                                                                                                    is: (value: any) => value is ColorInformation;

                                                                                                                                    namespace ColorPresentation

                                                                                                                                    namespace ColorPresentation {}
                                                                                                                                    • The Color namespace provides helper functions to work with ColorPresentation literals.

                                                                                                                                    function create

                                                                                                                                    create: (
                                                                                                                                    label: string,
                                                                                                                                    textEdit?: TextEdit,
                                                                                                                                    additionalTextEdits?: TextEdit[]
                                                                                                                                    ) => ColorPresentation;
                                                                                                                                    • Creates a new ColorInformation literal.

                                                                                                                                    function is

                                                                                                                                    is: (value: any) => value is ColorPresentation;

                                                                                                                                    namespace Command

                                                                                                                                    namespace Command {}
                                                                                                                                    • The Command namespace provides helper functions to work with Command literals.

                                                                                                                                    function create

                                                                                                                                    create: (title: string, command: string, ...args: any[]) => Command;
                                                                                                                                    • Creates a new Command literal.

                                                                                                                                    function is

                                                                                                                                    is: (value: any) => value is Command;
                                                                                                                                    • Checks whether the given literal conforms to the Command interface.

                                                                                                                                    namespace CompletionItem

                                                                                                                                    namespace CompletionItem {}
                                                                                                                                    • The CompletionItem namespace provides functions to deal with completion items.

                                                                                                                                    function create

                                                                                                                                    create: (label: string) => CompletionItem;
                                                                                                                                    • Create a completion item and seed it with a label.

                                                                                                                                      Parameter label

                                                                                                                                      The completion item's label

                                                                                                                                    namespace CompletionItemKind

                                                                                                                                    namespace CompletionItemKind {}
                                                                                                                                    • The kind of a completion entry.

                                                                                                                                    variable Class

                                                                                                                                    const Class: number;

                                                                                                                                      variable Color

                                                                                                                                      const Color: number;

                                                                                                                                        variable Constant

                                                                                                                                        const Constant: number;

                                                                                                                                          variable Constructor

                                                                                                                                          const Constructor: number;

                                                                                                                                            variable Enum

                                                                                                                                            const Enum: number;

                                                                                                                                              variable EnumMember

                                                                                                                                              const EnumMember: number;

                                                                                                                                                variable Event

                                                                                                                                                const Event: number;

                                                                                                                                                  variable Field

                                                                                                                                                  const Field: number;

                                                                                                                                                    variable File

                                                                                                                                                    const File: number;

                                                                                                                                                      variable Folder

                                                                                                                                                      const Folder: number;

                                                                                                                                                        variable Function

                                                                                                                                                        const Function: number;

                                                                                                                                                          variable Interface

                                                                                                                                                          const Interface: number;

                                                                                                                                                            variable Keyword

                                                                                                                                                            const Keyword: number;

                                                                                                                                                              variable Method

                                                                                                                                                              const Method: number;

                                                                                                                                                                variable Module

                                                                                                                                                                const Module: number;

                                                                                                                                                                  variable Operator

                                                                                                                                                                  const Operator: number;

                                                                                                                                                                    variable Property

                                                                                                                                                                    const Property: number;

                                                                                                                                                                      variable Reference

                                                                                                                                                                      const Reference: number;

                                                                                                                                                                        variable Snippet

                                                                                                                                                                        const Snippet: number;

                                                                                                                                                                          variable Struct

                                                                                                                                                                          const Struct: number;

                                                                                                                                                                            variable Text

                                                                                                                                                                            const Text: number;

                                                                                                                                                                              variable TypeParameter

                                                                                                                                                                              const TypeParameter: number;

                                                                                                                                                                                variable Unit

                                                                                                                                                                                const Unit: number;

                                                                                                                                                                                  variable Value

                                                                                                                                                                                  const Value: number;

                                                                                                                                                                                    variable Variable

                                                                                                                                                                                    const Variable: number;

                                                                                                                                                                                      namespace CompletionItemLabelDetails

                                                                                                                                                                                      namespace CompletionItemLabelDetails {}

                                                                                                                                                                                        function is

                                                                                                                                                                                        is: (value: any) => value is CompletionItemLabelDetails;

                                                                                                                                                                                          namespace CompletionItemTag

                                                                                                                                                                                          namespace CompletionItemTag {}
                                                                                                                                                                                          • Completion item tags are extra annotations that tweak the rendering of a completion item.

                                                                                                                                                                                            3.15.0

                                                                                                                                                                                          variable Deprecated

                                                                                                                                                                                          const Deprecated: number;
                                                                                                                                                                                          • Render a completion as obsolete, usually using a strike-out.

                                                                                                                                                                                          namespace CompletionList

                                                                                                                                                                                          namespace CompletionList {}
                                                                                                                                                                                          • The CompletionList namespace provides functions to deal with completion lists.

                                                                                                                                                                                          function create

                                                                                                                                                                                          create: (items?: CompletionItem[], isIncomplete?: boolean) => CompletionList;
                                                                                                                                                                                          • Creates a new completion list.

                                                                                                                                                                                            Parameter items

                                                                                                                                                                                            The completion items.

                                                                                                                                                                                            Parameter isIncomplete

                                                                                                                                                                                            The list is not complete.

                                                                                                                                                                                          namespace CreateFile

                                                                                                                                                                                          namespace CreateFile {}

                                                                                                                                                                                            function create

                                                                                                                                                                                            create: (
                                                                                                                                                                                            uri: DocumentUri,
                                                                                                                                                                                            options?: CreateFileOptions,
                                                                                                                                                                                            annotation?: ChangeAnnotationIdentifier
                                                                                                                                                                                            ) => CreateFile;

                                                                                                                                                                                              function is

                                                                                                                                                                                              is: (value: any) => value is CreateFile;

                                                                                                                                                                                                namespace DeleteFile

                                                                                                                                                                                                namespace DeleteFile {}

                                                                                                                                                                                                  function create

                                                                                                                                                                                                  create: (
                                                                                                                                                                                                  uri: DocumentUri,
                                                                                                                                                                                                  options?: DeleteFileOptions,
                                                                                                                                                                                                  annotation?: ChangeAnnotationIdentifier
                                                                                                                                                                                                  ) => DeleteFile;

                                                                                                                                                                                                    function is

                                                                                                                                                                                                    is: (value: any) => value is DeleteFile;

                                                                                                                                                                                                      namespace Diagnostic

                                                                                                                                                                                                      namespace Diagnostic {}
                                                                                                                                                                                                      • The Diagnostic namespace provides helper functions to work with Diagnostic literals.

                                                                                                                                                                                                      function create

                                                                                                                                                                                                      create: (
                                                                                                                                                                                                      range: Range,
                                                                                                                                                                                                      message: string,
                                                                                                                                                                                                      severity?: DiagnosticSeverity,
                                                                                                                                                                                                      code?: integer | string,
                                                                                                                                                                                                      source?: string,
                                                                                                                                                                                                      relatedInformation?: DiagnosticRelatedInformation[]
                                                                                                                                                                                                      ) => Diagnostic;
                                                                                                                                                                                                      • Creates a new Diagnostic literal.

                                                                                                                                                                                                      function is

                                                                                                                                                                                                      is: (value: any) => value is Diagnostic;
                                                                                                                                                                                                      • Checks whether the given literal conforms to the Diagnostic interface.

                                                                                                                                                                                                      namespace DiagnosticRelatedInformation

                                                                                                                                                                                                      namespace DiagnosticRelatedInformation {}

                                                                                                                                                                                                      function create

                                                                                                                                                                                                      create: (location: Location, message: string) => DiagnosticRelatedInformation;
                                                                                                                                                                                                      • Creates a new DiagnosticRelatedInformation literal.

                                                                                                                                                                                                      function is

                                                                                                                                                                                                      is: (value: any) => value is DiagnosticRelatedInformation;

                                                                                                                                                                                                      namespace DiagnosticSeverity

                                                                                                                                                                                                      namespace DiagnosticSeverity {}
                                                                                                                                                                                                      • The diagnostic's severity.

                                                                                                                                                                                                      variable Error

                                                                                                                                                                                                      const Error: number;
                                                                                                                                                                                                      • Reports an error.

                                                                                                                                                                                                      variable Hint

                                                                                                                                                                                                      const Hint: number;
                                                                                                                                                                                                      • Reports a hint.

                                                                                                                                                                                                      variable Information

                                                                                                                                                                                                      const Information: number;
                                                                                                                                                                                                      • Reports an information.

                                                                                                                                                                                                      variable Warning

                                                                                                                                                                                                      const Warning: number;
                                                                                                                                                                                                      • Reports a warning.

                                                                                                                                                                                                      namespace DiagnosticTag

                                                                                                                                                                                                      namespace DiagnosticTag {}
                                                                                                                                                                                                      • The diagnostic tags.

                                                                                                                                                                                                        3.15.0

                                                                                                                                                                                                      variable Deprecated

                                                                                                                                                                                                      const Deprecated: number;
                                                                                                                                                                                                      • Deprecated or obsolete code.

                                                                                                                                                                                                        Clients are allowed to rendered diagnostics with this tag strike through.

                                                                                                                                                                                                      variable Unnecessary

                                                                                                                                                                                                      const Unnecessary: number;
                                                                                                                                                                                                      • Unused or unnecessary code.

                                                                                                                                                                                                        Clients are allowed to render diagnostics with this tag faded out instead of having an error squiggle.

                                                                                                                                                                                                      namespace DocumentHighlight

                                                                                                                                                                                                      namespace DocumentHighlight {}
                                                                                                                                                                                                      • DocumentHighlight namespace to provide helper functions to work with DocumentHighlight literals.

                                                                                                                                                                                                      function create

                                                                                                                                                                                                      create: (range: Range, kind?: DocumentHighlightKind) => DocumentHighlight;
                                                                                                                                                                                                      • Create a DocumentHighlight object.

                                                                                                                                                                                                        Parameter range

                                                                                                                                                                                                        The range the highlight applies to.

                                                                                                                                                                                                        Parameter kind

                                                                                                                                                                                                        The highlight kind

                                                                                                                                                                                                      namespace DocumentHighlightKind

                                                                                                                                                                                                      namespace DocumentHighlightKind {}
                                                                                                                                                                                                      • A document highlight kind.

                                                                                                                                                                                                      variable Read

                                                                                                                                                                                                      const Read: number;
                                                                                                                                                                                                      • Read-access of a symbol, like reading a variable.

                                                                                                                                                                                                      variable Text

                                                                                                                                                                                                      const Text: number;
                                                                                                                                                                                                      • A textual occurrence.

                                                                                                                                                                                                      variable Write

                                                                                                                                                                                                      const Write: number;
                                                                                                                                                                                                      • Write-access of a symbol, like writing to a variable.

                                                                                                                                                                                                      namespace DocumentLink {}
                                                                                                                                                                                                      • The DocumentLink namespace provides helper functions to work with DocumentLink literals.

                                                                                                                                                                                                      function create

                                                                                                                                                                                                      create: (range: Range, target?: string, data?: LSPAny) => DocumentLink;
                                                                                                                                                                                                      • Creates a new DocumentLink literal.

                                                                                                                                                                                                      function is

                                                                                                                                                                                                      is: (value: any) => value is DocumentLink;
                                                                                                                                                                                                      • Checks whether the given literal conforms to the DocumentLink interface.

                                                                                                                                                                                                      namespace DocumentSymbol

                                                                                                                                                                                                      namespace DocumentSymbol {}

                                                                                                                                                                                                        function create

                                                                                                                                                                                                        create: (
                                                                                                                                                                                                        name: string,
                                                                                                                                                                                                        detail: string | undefined,
                                                                                                                                                                                                        kind: SymbolKind,
                                                                                                                                                                                                        range: Range,
                                                                                                                                                                                                        selectionRange: Range,
                                                                                                                                                                                                        children?: DocumentSymbol[]
                                                                                                                                                                                                        ) => DocumentSymbol;
                                                                                                                                                                                                        • Creates a new symbol information literal.

                                                                                                                                                                                                          Parameter name

                                                                                                                                                                                                          The name of the symbol.

                                                                                                                                                                                                          Parameter detail

                                                                                                                                                                                                          The detail of the symbol.

                                                                                                                                                                                                          Parameter kind

                                                                                                                                                                                                          The kind of the symbol.

                                                                                                                                                                                                          Parameter range

                                                                                                                                                                                                          The range of the symbol.

                                                                                                                                                                                                          Parameter selectionRange

                                                                                                                                                                                                          The selectionRange of the symbol.

                                                                                                                                                                                                          Parameter children

                                                                                                                                                                                                          Children of the symbol.

                                                                                                                                                                                                        function is

                                                                                                                                                                                                        is: (value: any) => value is DocumentSymbol;
                                                                                                                                                                                                        • Checks whether the given literal conforms to the DocumentSymbol interface.

                                                                                                                                                                                                        namespace DocumentUri

                                                                                                                                                                                                        namespace DocumentUri {}

                                                                                                                                                                                                          function is

                                                                                                                                                                                                          is: (value: any) => value is string;

                                                                                                                                                                                                            namespace FoldingRange

                                                                                                                                                                                                            namespace FoldingRange {}
                                                                                                                                                                                                            • The folding range namespace provides helper functions to work with FoldingRange literals.

                                                                                                                                                                                                            function create

                                                                                                                                                                                                            create: (
                                                                                                                                                                                                            startLine: uinteger,
                                                                                                                                                                                                            endLine: uinteger,
                                                                                                                                                                                                            startCharacter?: uinteger,
                                                                                                                                                                                                            endCharacter?: uinteger,
                                                                                                                                                                                                            kind?: FoldingRangeKind,
                                                                                                                                                                                                            collapsedText?: string
                                                                                                                                                                                                            ) => FoldingRange;
                                                                                                                                                                                                            • Creates a new FoldingRange literal.

                                                                                                                                                                                                            function is

                                                                                                                                                                                                            is: (value: any) => value is FoldingRange;
                                                                                                                                                                                                            • Checks whether the given literal conforms to the FoldingRange interface.

                                                                                                                                                                                                            namespace FoldingRangeKind

                                                                                                                                                                                                            namespace FoldingRangeKind {}
                                                                                                                                                                                                            • A set of predefined range kinds.

                                                                                                                                                                                                            variable Comment

                                                                                                                                                                                                            const Comment: string;
                                                                                                                                                                                                            • Folding range for a comment

                                                                                                                                                                                                            variable Imports

                                                                                                                                                                                                            const Imports: string;
                                                                                                                                                                                                            • Folding range for an import or include

                                                                                                                                                                                                            variable Region

                                                                                                                                                                                                            const Region: string;
                                                                                                                                                                                                            • Folding range for a region (e.g. #region)

                                                                                                                                                                                                            namespace FormattingOptions

                                                                                                                                                                                                            namespace FormattingOptions {}
                                                                                                                                                                                                            • The FormattingOptions namespace provides helper functions to work with FormattingOptions literals.

                                                                                                                                                                                                            function create

                                                                                                                                                                                                            create: (tabSize: uinteger, insertSpaces: boolean) => FormattingOptions;
                                                                                                                                                                                                            • Creates a new FormattingOptions literal.

                                                                                                                                                                                                            function is

                                                                                                                                                                                                            is: (value: any) => value is FormattingOptions;

                                                                                                                                                                                                            namespace Hover

                                                                                                                                                                                                            namespace Hover {}

                                                                                                                                                                                                              function is

                                                                                                                                                                                                              is: (value: any) => value is Hover;
                                                                                                                                                                                                              • Checks whether the given value conforms to the Hover interface.

                                                                                                                                                                                                              namespace InlayHint

                                                                                                                                                                                                              namespace InlayHint {}

                                                                                                                                                                                                                function create

                                                                                                                                                                                                                create: (
                                                                                                                                                                                                                position: Position,
                                                                                                                                                                                                                label: string | InlayHintLabelPart[],
                                                                                                                                                                                                                kind?: InlayHintKind
                                                                                                                                                                                                                ) => InlayHint;

                                                                                                                                                                                                                  function is

                                                                                                                                                                                                                  is: (value: any) => value is InlayHint;

                                                                                                                                                                                                                    namespace InlayHintKind

                                                                                                                                                                                                                    namespace InlayHintKind {}
                                                                                                                                                                                                                    • Inlay hint kinds.

                                                                                                                                                                                                                      3.17.0

                                                                                                                                                                                                                    variable Parameter

                                                                                                                                                                                                                    const Parameter: number;
                                                                                                                                                                                                                    • An inlay hint that is for a parameter.

                                                                                                                                                                                                                    variable Type

                                                                                                                                                                                                                    const Type: number;
                                                                                                                                                                                                                    • An inlay hint that for a type annotation.

                                                                                                                                                                                                                    function is

                                                                                                                                                                                                                    is: (value: number) => value is InlayHintKind;

                                                                                                                                                                                                                      namespace InlayHintLabelPart

                                                                                                                                                                                                                      namespace InlayHintLabelPart {}

                                                                                                                                                                                                                        function create

                                                                                                                                                                                                                        create: (value: string) => InlayHintLabelPart;

                                                                                                                                                                                                                          function is

                                                                                                                                                                                                                          is: (value: any) => value is InlayHintLabelPart;

                                                                                                                                                                                                                            namespace InlineCompletionContext

                                                                                                                                                                                                                            namespace InlineCompletionContext {}

                                                                                                                                                                                                                              function create

                                                                                                                                                                                                                              create: (
                                                                                                                                                                                                                              triggerKind: InlineCompletionTriggerKind,
                                                                                                                                                                                                                              selectedCompletionInfo?: SelectedCompletionInfo
                                                                                                                                                                                                                              ) => InlineCompletionContext;

                                                                                                                                                                                                                                namespace InlineCompletionItem

                                                                                                                                                                                                                                namespace InlineCompletionItem {}

                                                                                                                                                                                                                                  function create

                                                                                                                                                                                                                                  create: (
                                                                                                                                                                                                                                  insertText: string | StringValue,
                                                                                                                                                                                                                                  filterText?: string,
                                                                                                                                                                                                                                  range?: Range,
                                                                                                                                                                                                                                  command?: Command
                                                                                                                                                                                                                                  ) => InlineCompletionItem;

                                                                                                                                                                                                                                    namespace InlineCompletionList

                                                                                                                                                                                                                                    namespace InlineCompletionList {}

                                                                                                                                                                                                                                      function create

                                                                                                                                                                                                                                      create: (items: InlineCompletionItem[]) => InlineCompletionList;

                                                                                                                                                                                                                                        namespace InlineCompletionTriggerKind

                                                                                                                                                                                                                                        namespace InlineCompletionTriggerKind {}
                                                                                                                                                                                                                                        • Describes how an was triggered.

                                                                                                                                                                                                                                          3.18.0

                                                                                                                                                                                                                                        variable Automatic

                                                                                                                                                                                                                                        const Automatic: number;
                                                                                                                                                                                                                                        • Completion was triggered automatically while editing.

                                                                                                                                                                                                                                        variable Invoked

                                                                                                                                                                                                                                        const Invoked: number;
                                                                                                                                                                                                                                        • Completion was triggered explicitly by a user gesture.

                                                                                                                                                                                                                                        namespace InlineValueContext

                                                                                                                                                                                                                                        namespace InlineValueContext {}
                                                                                                                                                                                                                                        • The InlineValueContext namespace provides helper functions to work with InlineValueContext literals.

                                                                                                                                                                                                                                          3.17.0

                                                                                                                                                                                                                                        function create

                                                                                                                                                                                                                                        create: (frameId: integer, stoppedLocation: Range) => InlineValueContext;
                                                                                                                                                                                                                                        • Creates a new InlineValueContext literal.

                                                                                                                                                                                                                                        function is

                                                                                                                                                                                                                                        is: (value: any) => value is InlineValueContext;

                                                                                                                                                                                                                                        namespace InlineValueEvaluatableExpression

                                                                                                                                                                                                                                        namespace InlineValueEvaluatableExpression {}
                                                                                                                                                                                                                                        • The InlineValueEvaluatableExpression namespace provides functions to deal with InlineValueEvaluatableExpression.

                                                                                                                                                                                                                                          3.17.0

                                                                                                                                                                                                                                        function create

                                                                                                                                                                                                                                        create: (
                                                                                                                                                                                                                                        range: Range,
                                                                                                                                                                                                                                        expression: string | undefined
                                                                                                                                                                                                                                        ) => InlineValueEvaluatableExpression;
                                                                                                                                                                                                                                        • Creates a new InlineValueEvaluatableExpression literal.

                                                                                                                                                                                                                                        function is

                                                                                                                                                                                                                                        is: (
                                                                                                                                                                                                                                        value: InlineValue | undefined | null
                                                                                                                                                                                                                                        ) => value is InlineValueEvaluatableExpression;

                                                                                                                                                                                                                                          namespace InlineValueText

                                                                                                                                                                                                                                          namespace InlineValueText {}
                                                                                                                                                                                                                                          • The InlineValueText namespace provides functions to deal with InlineValueTexts.

                                                                                                                                                                                                                                            3.17.0

                                                                                                                                                                                                                                          function create

                                                                                                                                                                                                                                          create: (range: Range, text: string) => InlineValueText;
                                                                                                                                                                                                                                          • Creates a new InlineValueText literal.

                                                                                                                                                                                                                                          function is

                                                                                                                                                                                                                                          is: (value: InlineValue | undefined | null) => value is InlineValueText;

                                                                                                                                                                                                                                            namespace InlineValueVariableLookup

                                                                                                                                                                                                                                            namespace InlineValueVariableLookup {}
                                                                                                                                                                                                                                            • The InlineValueVariableLookup namespace provides functions to deal with InlineValueVariableLookups.

                                                                                                                                                                                                                                              3.17.0

                                                                                                                                                                                                                                            function create

                                                                                                                                                                                                                                            create: (
                                                                                                                                                                                                                                            range: Range,
                                                                                                                                                                                                                                            variableName: string | undefined,
                                                                                                                                                                                                                                            caseSensitiveLookup: boolean
                                                                                                                                                                                                                                            ) => InlineValueVariableLookup;
                                                                                                                                                                                                                                            • Creates a new InlineValueText literal.

                                                                                                                                                                                                                                            function is

                                                                                                                                                                                                                                            is: (
                                                                                                                                                                                                                                            value: InlineValue | undefined | null
                                                                                                                                                                                                                                            ) => value is InlineValueVariableLookup;

                                                                                                                                                                                                                                              namespace InsertReplaceEdit

                                                                                                                                                                                                                                              namespace InsertReplaceEdit {}
                                                                                                                                                                                                                                              • The InsertReplaceEdit namespace provides functions to deal with insert / replace edits.

                                                                                                                                                                                                                                                3.16.0

                                                                                                                                                                                                                                              function create

                                                                                                                                                                                                                                              create: (newText: string, insert: Range, replace: Range) => InsertReplaceEdit;
                                                                                                                                                                                                                                              • Creates a new insert / replace edit

                                                                                                                                                                                                                                              function is

                                                                                                                                                                                                                                              is: (value: TextEdit | InsertReplaceEdit) => value is InsertReplaceEdit;

                                                                                                                                                                                                                                              namespace InsertTextFormat

                                                                                                                                                                                                                                              namespace InsertTextFormat {}
                                                                                                                                                                                                                                              • Defines whether the insert text in a completion item should be interpreted as plain text or a snippet.

                                                                                                                                                                                                                                              variable PlainText

                                                                                                                                                                                                                                              const PlainText: number;
                                                                                                                                                                                                                                              • The primary text to be inserted is treated as a plain string.

                                                                                                                                                                                                                                              variable Snippet

                                                                                                                                                                                                                                              const Snippet: number;
                                                                                                                                                                                                                                              • The primary text to be inserted is treated as a snippet.

                                                                                                                                                                                                                                                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. Placeholders with equal identifiers are linked, that is typing in one will update others too.

                                                                                                                                                                                                                                                See also: https://microsoft.github.io/language-server-protocol/specifications/specification-current/#snippet_syntax

                                                                                                                                                                                                                                              namespace InsertTextMode

                                                                                                                                                                                                                                              namespace InsertTextMode {}
                                                                                                                                                                                                                                              • How whitespace and indentation is handled during completion item insertion.

                                                                                                                                                                                                                                                3.16.0

                                                                                                                                                                                                                                              variable adjustIndentation

                                                                                                                                                                                                                                              const adjustIndentation: number;
                                                                                                                                                                                                                                              • The editor adjusts leading whitespace of new lines so that they match the indentation up to the cursor of the line for which the item is accepted.

                                                                                                                                                                                                                                                Consider a line like this: <2tabs><3tabs>foo. Accepting a multi line completion item is indented using 2 tabs and all following lines inserted will be indented using 2 tabs as well.

                                                                                                                                                                                                                                              variable asIs

                                                                                                                                                                                                                                              const asIs: number;
                                                                                                                                                                                                                                              • The insertion or replace strings is taken as it is. If the value is multi line the lines below the cursor will be inserted using the indentation defined in the string value. The client will not apply any kind of adjustments to the string.

                                                                                                                                                                                                                                              namespace integer

                                                                                                                                                                                                                                              namespace integer {}

                                                                                                                                                                                                                                                variable MAX_VALUE

                                                                                                                                                                                                                                                const MAX_VALUE: number;

                                                                                                                                                                                                                                                  variable MIN_VALUE

                                                                                                                                                                                                                                                  const MIN_VALUE: number;

                                                                                                                                                                                                                                                    function is

                                                                                                                                                                                                                                                    is: (value: any) => value is number;

                                                                                                                                                                                                                                                      namespace Location

                                                                                                                                                                                                                                                      namespace Location {}
                                                                                                                                                                                                                                                      • The Location namespace provides helper functions to work with Location literals.

                                                                                                                                                                                                                                                      function create

                                                                                                                                                                                                                                                      create: (uri: DocumentUri, range: Range) => Location;
                                                                                                                                                                                                                                                      • Creates a Location literal.

                                                                                                                                                                                                                                                        Parameter uri

                                                                                                                                                                                                                                                        The location's uri.

                                                                                                                                                                                                                                                        Parameter range

                                                                                                                                                                                                                                                        The location's range.

                                                                                                                                                                                                                                                      function is

                                                                                                                                                                                                                                                      is: (value: any) => value is Location;
                                                                                                                                                                                                                                                      • Checks whether the given literal conforms to the Location interface.

                                                                                                                                                                                                                                                      namespace LocationLink {}
                                                                                                                                                                                                                                                      • The LocationLink namespace provides helper functions to work with LocationLink literals.

                                                                                                                                                                                                                                                      function create

                                                                                                                                                                                                                                                      create: (
                                                                                                                                                                                                                                                      targetUri: DocumentUri,
                                                                                                                                                                                                                                                      targetRange: Range,
                                                                                                                                                                                                                                                      targetSelectionRange: Range,
                                                                                                                                                                                                                                                      originSelectionRange?: Range
                                                                                                                                                                                                                                                      ) => LocationLink;
                                                                                                                                                                                                                                                      • Creates a LocationLink literal.

                                                                                                                                                                                                                                                        Parameter targetUri

                                                                                                                                                                                                                                                        The definition's uri.

                                                                                                                                                                                                                                                        Parameter targetRange

                                                                                                                                                                                                                                                        The full range of the definition.

                                                                                                                                                                                                                                                        Parameter targetSelectionRange

                                                                                                                                                                                                                                                        The span of the symbol definition at the target.

                                                                                                                                                                                                                                                        Parameter originSelectionRange

                                                                                                                                                                                                                                                        The span of the symbol being defined in the originating source file.

                                                                                                                                                                                                                                                      function is

                                                                                                                                                                                                                                                      is: (value: any) => value is LocationLink;
                                                                                                                                                                                                                                                      • Checks whether the given literal conforms to the LocationLink interface.

                                                                                                                                                                                                                                                      namespace MarkedString

                                                                                                                                                                                                                                                      namespace MarkedString {}

                                                                                                                                                                                                                                                        function fromPlainText

                                                                                                                                                                                                                                                        fromPlainText: (plainText: string) => string;
                                                                                                                                                                                                                                                        • Creates a marked string from plain text.

                                                                                                                                                                                                                                                          Parameter plainText

                                                                                                                                                                                                                                                          The plain text.

                                                                                                                                                                                                                                                        function is

                                                                                                                                                                                                                                                        is: (value: any) => value is MarkedString;
                                                                                                                                                                                                                                                        • Checks whether the given value conforms to the MarkedString type.

                                                                                                                                                                                                                                                        namespace MarkupContent

                                                                                                                                                                                                                                                        namespace MarkupContent {}

                                                                                                                                                                                                                                                          function is

                                                                                                                                                                                                                                                          is: (value: any) => value is MarkupContent;
                                                                                                                                                                                                                                                          • Checks whether the given value conforms to the MarkupContent interface.

                                                                                                                                                                                                                                                          namespace MarkupKind

                                                                                                                                                                                                                                                          namespace MarkupKind {}
                                                                                                                                                                                                                                                          • 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.

                                                                                                                                                                                                                                                          variable Markdown

                                                                                                                                                                                                                                                          const Markdown: string;
                                                                                                                                                                                                                                                          • Markdown is supported as a content format

                                                                                                                                                                                                                                                          variable PlainText

                                                                                                                                                                                                                                                          const PlainText: string;
                                                                                                                                                                                                                                                          • Plain text is supported as a content format

                                                                                                                                                                                                                                                          function is

                                                                                                                                                                                                                                                          is: (value: any) => value is MarkupKind;
                                                                                                                                                                                                                                                          • Checks whether the given value is a value of the MarkupKind type.

                                                                                                                                                                                                                                                          namespace OptionalVersionedTextDocumentIdentifier

                                                                                                                                                                                                                                                          namespace OptionalVersionedTextDocumentIdentifier {}

                                                                                                                                                                                                                                                          function create

                                                                                                                                                                                                                                                          create: (
                                                                                                                                                                                                                                                          uri: DocumentUri,
                                                                                                                                                                                                                                                          version: integer | null
                                                                                                                                                                                                                                                          ) => OptionalVersionedTextDocumentIdentifier;
                                                                                                                                                                                                                                                          • Creates a new OptionalVersionedTextDocumentIdentifier literal.

                                                                                                                                                                                                                                                            Parameter uri

                                                                                                                                                                                                                                                            The document's uri.

                                                                                                                                                                                                                                                            Parameter version

                                                                                                                                                                                                                                                            The document's version.

                                                                                                                                                                                                                                                          function is

                                                                                                                                                                                                                                                          is: (value: any) => value is OptionalVersionedTextDocumentIdentifier;

                                                                                                                                                                                                                                                          namespace ParameterInformation

                                                                                                                                                                                                                                                          namespace ParameterInformation {}
                                                                                                                                                                                                                                                          • The ParameterInformation namespace provides helper functions to work with ParameterInformation literals.

                                                                                                                                                                                                                                                          function create

                                                                                                                                                                                                                                                          create: (
                                                                                                                                                                                                                                                          label: string | [uinteger, uinteger],
                                                                                                                                                                                                                                                          documentation?: string
                                                                                                                                                                                                                                                          ) => ParameterInformation;
                                                                                                                                                                                                                                                          • Creates a new parameter information literal.

                                                                                                                                                                                                                                                            Parameter label

                                                                                                                                                                                                                                                            A label string.

                                                                                                                                                                                                                                                            Parameter documentation

                                                                                                                                                                                                                                                            A doc string.

                                                                                                                                                                                                                                                          namespace Position

                                                                                                                                                                                                                                                          namespace Position {}
                                                                                                                                                                                                                                                          • The Position namespace provides helper functions to work with Position literals.

                                                                                                                                                                                                                                                          function create

                                                                                                                                                                                                                                                          create: (line: uinteger, character: uinteger) => Position;
                                                                                                                                                                                                                                                          • Creates a new Position literal from the given line and character.

                                                                                                                                                                                                                                                            Parameter line

                                                                                                                                                                                                                                                            The position's line.

                                                                                                                                                                                                                                                            Parameter character

                                                                                                                                                                                                                                                            The position's character.

                                                                                                                                                                                                                                                          function is

                                                                                                                                                                                                                                                          is: (value: any) => value is Position;
                                                                                                                                                                                                                                                          • Checks whether the given literal conforms to the Position interface.

                                                                                                                                                                                                                                                          namespace Range

                                                                                                                                                                                                                                                          namespace Range {}
                                                                                                                                                                                                                                                          • The Range namespace provides helper functions to work with Range literals.

                                                                                                                                                                                                                                                          function create

                                                                                                                                                                                                                                                          create: {
                                                                                                                                                                                                                                                          (start: Position, end: Position): Range;
                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                          startLine: number,
                                                                                                                                                                                                                                                          startCharacter: number,
                                                                                                                                                                                                                                                          endLine: number,
                                                                                                                                                                                                                                                          endCharacter: number
                                                                                                                                                                                                                                                          ): Range;
                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                          • Create a new Range literal.

                                                                                                                                                                                                                                                            Parameter start

                                                                                                                                                                                                                                                            The range's start position.

                                                                                                                                                                                                                                                            Parameter end

                                                                                                                                                                                                                                                            The range's end position.

                                                                                                                                                                                                                                                          • Create a new Range literal.

                                                                                                                                                                                                                                                            Parameter startLine

                                                                                                                                                                                                                                                            The start line number.

                                                                                                                                                                                                                                                            Parameter startCharacter

                                                                                                                                                                                                                                                            The start character.

                                                                                                                                                                                                                                                            Parameter endLine

                                                                                                                                                                                                                                                            The end line number.

                                                                                                                                                                                                                                                            Parameter endCharacter

                                                                                                                                                                                                                                                            The end character.

                                                                                                                                                                                                                                                          function is

                                                                                                                                                                                                                                                          is: (value: any) => value is Range;
                                                                                                                                                                                                                                                          • Checks whether the given literal conforms to the Range interface.

                                                                                                                                                                                                                                                          namespace RenameFile

                                                                                                                                                                                                                                                          namespace RenameFile {}

                                                                                                                                                                                                                                                            function create

                                                                                                                                                                                                                                                            create: (
                                                                                                                                                                                                                                                            oldUri: DocumentUri,
                                                                                                                                                                                                                                                            newUri: DocumentUri,
                                                                                                                                                                                                                                                            options?: RenameFileOptions,
                                                                                                                                                                                                                                                            annotation?: ChangeAnnotationIdentifier
                                                                                                                                                                                                                                                            ) => RenameFile;

                                                                                                                                                                                                                                                              function is

                                                                                                                                                                                                                                                              is: (value: any) => value is RenameFile;

                                                                                                                                                                                                                                                                namespace SelectedCompletionInfo

                                                                                                                                                                                                                                                                namespace SelectedCompletionInfo {}

                                                                                                                                                                                                                                                                  function create

                                                                                                                                                                                                                                                                  create: (range: Range, text: string) => SelectedCompletionInfo;

                                                                                                                                                                                                                                                                    namespace SelectionRange

                                                                                                                                                                                                                                                                    namespace SelectionRange {}
                                                                                                                                                                                                                                                                    • The SelectionRange namespace provides helper function to work with SelectionRange literals.

                                                                                                                                                                                                                                                                    function create

                                                                                                                                                                                                                                                                    create: (range: Range, parent?: SelectionRange) => SelectionRange;
                                                                                                                                                                                                                                                                    • Creates a new SelectionRange

                                                                                                                                                                                                                                                                      Parameter range

                                                                                                                                                                                                                                                                      the range.

                                                                                                                                                                                                                                                                      Parameter parent

                                                                                                                                                                                                                                                                      an optional parent.

                                                                                                                                                                                                                                                                    function is

                                                                                                                                                                                                                                                                    is: (value: any) => value is SelectionRange;

                                                                                                                                                                                                                                                                      namespace SemanticTokens

                                                                                                                                                                                                                                                                      namespace SemanticTokens {}
                                                                                                                                                                                                                                                                      • 3.16.0

                                                                                                                                                                                                                                                                      function is

                                                                                                                                                                                                                                                                      is: (value: any) => value is SemanticTokens;

                                                                                                                                                                                                                                                                        namespace SignatureInformation

                                                                                                                                                                                                                                                                        namespace SignatureInformation {}
                                                                                                                                                                                                                                                                        • The SignatureInformation namespace provides helper functions to work with SignatureInformation literals.

                                                                                                                                                                                                                                                                        function create

                                                                                                                                                                                                                                                                        create: (
                                                                                                                                                                                                                                                                        label: string,
                                                                                                                                                                                                                                                                        documentation?: string,
                                                                                                                                                                                                                                                                        ...parameters: ParameterInformation[]
                                                                                                                                                                                                                                                                        ) => SignatureInformation;

                                                                                                                                                                                                                                                                          namespace StringValue

                                                                                                                                                                                                                                                                          namespace StringValue {}

                                                                                                                                                                                                                                                                            function createSnippet

                                                                                                                                                                                                                                                                            createSnippet: (value: string) => StringValue;

                                                                                                                                                                                                                                                                              namespace SymbolInformation

                                                                                                                                                                                                                                                                              namespace SymbolInformation {}

                                                                                                                                                                                                                                                                                function create

                                                                                                                                                                                                                                                                                create: (
                                                                                                                                                                                                                                                                                name: string,
                                                                                                                                                                                                                                                                                kind: SymbolKind,
                                                                                                                                                                                                                                                                                range: Range,
                                                                                                                                                                                                                                                                                uri: DocumentUri,
                                                                                                                                                                                                                                                                                containerName?: string
                                                                                                                                                                                                                                                                                ) => SymbolInformation;
                                                                                                                                                                                                                                                                                • Creates a new symbol information literal.

                                                                                                                                                                                                                                                                                  Parameter name

                                                                                                                                                                                                                                                                                  The name of the symbol.

                                                                                                                                                                                                                                                                                  Parameter kind

                                                                                                                                                                                                                                                                                  The kind of the symbol.

                                                                                                                                                                                                                                                                                  Parameter range

                                                                                                                                                                                                                                                                                  The range of the location of the symbol.

                                                                                                                                                                                                                                                                                  Parameter uri

                                                                                                                                                                                                                                                                                  The resource of the location of symbol.

                                                                                                                                                                                                                                                                                  Parameter containerName

                                                                                                                                                                                                                                                                                  The name of the symbol containing the symbol.

                                                                                                                                                                                                                                                                                namespace SymbolKind

                                                                                                                                                                                                                                                                                namespace SymbolKind {}
                                                                                                                                                                                                                                                                                • A symbol kind.

                                                                                                                                                                                                                                                                                variable Array

                                                                                                                                                                                                                                                                                const Array: number;

                                                                                                                                                                                                                                                                                  variable Boolean

                                                                                                                                                                                                                                                                                  const Boolean: number;

                                                                                                                                                                                                                                                                                    variable Class

                                                                                                                                                                                                                                                                                    const Class: number;

                                                                                                                                                                                                                                                                                      variable Constant

                                                                                                                                                                                                                                                                                      const Constant: number;

                                                                                                                                                                                                                                                                                        variable Constructor

                                                                                                                                                                                                                                                                                        const Constructor: number;

                                                                                                                                                                                                                                                                                          variable Enum

                                                                                                                                                                                                                                                                                          const Enum: number;

                                                                                                                                                                                                                                                                                            variable EnumMember

                                                                                                                                                                                                                                                                                            const EnumMember: number;

                                                                                                                                                                                                                                                                                              variable Event

                                                                                                                                                                                                                                                                                              const Event: number;

                                                                                                                                                                                                                                                                                                variable Field

                                                                                                                                                                                                                                                                                                const Field: number;

                                                                                                                                                                                                                                                                                                  variable File

                                                                                                                                                                                                                                                                                                  const File: number;

                                                                                                                                                                                                                                                                                                    variable Function

                                                                                                                                                                                                                                                                                                    const Function: number;

                                                                                                                                                                                                                                                                                                      variable Interface

                                                                                                                                                                                                                                                                                                      const Interface: number;

                                                                                                                                                                                                                                                                                                        variable Key

                                                                                                                                                                                                                                                                                                        const Key: number;

                                                                                                                                                                                                                                                                                                          variable Method

                                                                                                                                                                                                                                                                                                          const Method: number;

                                                                                                                                                                                                                                                                                                            variable Module

                                                                                                                                                                                                                                                                                                            const Module: number;

                                                                                                                                                                                                                                                                                                              variable Namespace

                                                                                                                                                                                                                                                                                                              const Namespace: number;

                                                                                                                                                                                                                                                                                                                variable Null

                                                                                                                                                                                                                                                                                                                const Null: number;

                                                                                                                                                                                                                                                                                                                  variable Number

                                                                                                                                                                                                                                                                                                                  const Number: number;

                                                                                                                                                                                                                                                                                                                    variable Object

                                                                                                                                                                                                                                                                                                                    const Object: number;

                                                                                                                                                                                                                                                                                                                      variable Operator

                                                                                                                                                                                                                                                                                                                      const Operator: number;

                                                                                                                                                                                                                                                                                                                        variable Package

                                                                                                                                                                                                                                                                                                                        const Package: number;

                                                                                                                                                                                                                                                                                                                          variable Property

                                                                                                                                                                                                                                                                                                                          const Property: number;

                                                                                                                                                                                                                                                                                                                            variable String

                                                                                                                                                                                                                                                                                                                            const String: number;

                                                                                                                                                                                                                                                                                                                              variable Struct

                                                                                                                                                                                                                                                                                                                              const Struct: number;

                                                                                                                                                                                                                                                                                                                                variable TypeParameter

                                                                                                                                                                                                                                                                                                                                const TypeParameter: number;

                                                                                                                                                                                                                                                                                                                                  variable Variable

                                                                                                                                                                                                                                                                                                                                  const Variable: number;

                                                                                                                                                                                                                                                                                                                                    namespace SymbolTag

                                                                                                                                                                                                                                                                                                                                    namespace SymbolTag {}
                                                                                                                                                                                                                                                                                                                                    • Symbol tags are extra annotations that tweak the rendering of a symbol.

                                                                                                                                                                                                                                                                                                                                      3.16

                                                                                                                                                                                                                                                                                                                                    variable Deprecated

                                                                                                                                                                                                                                                                                                                                    const Deprecated: number;
                                                                                                                                                                                                                                                                                                                                    • Render a symbol as obsolete, usually using a strike-out.

                                                                                                                                                                                                                                                                                                                                    namespace TextDocument

                                                                                                                                                                                                                                                                                                                                    namespace TextDocument {}
                                                                                                                                                                                                                                                                                                                                    • Deprecated

                                                                                                                                                                                                                                                                                                                                      Use the text document from the new vscode-languageserver-textdocument package.

                                                                                                                                                                                                                                                                                                                                    function applyEdits

                                                                                                                                                                                                                                                                                                                                    applyEdits: (document: TextDocument, edits: TextEdit[]) => string;

                                                                                                                                                                                                                                                                                                                                      function create

                                                                                                                                                                                                                                                                                                                                      create: (
                                                                                                                                                                                                                                                                                                                                      uri: DocumentUri,
                                                                                                                                                                                                                                                                                                                                      languageId: string,
                                                                                                                                                                                                                                                                                                                                      version: integer,
                                                                                                                                                                                                                                                                                                                                      content: string
                                                                                                                                                                                                                                                                                                                                      ) => TextDocument;
                                                                                                                                                                                                                                                                                                                                      • Creates a new ITextDocument literal from the given uri and content.

                                                                                                                                                                                                                                                                                                                                        Parameter uri

                                                                                                                                                                                                                                                                                                                                        The document's uri.

                                                                                                                                                                                                                                                                                                                                        Parameter languageId

                                                                                                                                                                                                                                                                                                                                        The document's language Id.

                                                                                                                                                                                                                                                                                                                                        Parameter version

                                                                                                                                                                                                                                                                                                                                        The document's version.

                                                                                                                                                                                                                                                                                                                                        Parameter content

                                                                                                                                                                                                                                                                                                                                        The document's content.

                                                                                                                                                                                                                                                                                                                                      function is

                                                                                                                                                                                                                                                                                                                                      is: (value: any) => value is TextDocument;
                                                                                                                                                                                                                                                                                                                                      • Checks whether the given literal conforms to the ITextDocument interface.

                                                                                                                                                                                                                                                                                                                                      namespace TextDocumentEdit

                                                                                                                                                                                                                                                                                                                                      namespace TextDocumentEdit {}
                                                                                                                                                                                                                                                                                                                                      • The TextDocumentEdit namespace provides helper function to create an edit that manipulates a text document.

                                                                                                                                                                                                                                                                                                                                      function create

                                                                                                                                                                                                                                                                                                                                      create: (
                                                                                                                                                                                                                                                                                                                                      textDocument: OptionalVersionedTextDocumentIdentifier,
                                                                                                                                                                                                                                                                                                                                      edits: (TextEdit | AnnotatedTextEdit)[]
                                                                                                                                                                                                                                                                                                                                      ) => TextDocumentEdit;
                                                                                                                                                                                                                                                                                                                                      • Creates a new TextDocumentEdit

                                                                                                                                                                                                                                                                                                                                      function is

                                                                                                                                                                                                                                                                                                                                      is: (value: any) => value is TextDocumentEdit;

                                                                                                                                                                                                                                                                                                                                        namespace TextDocumentIdentifier

                                                                                                                                                                                                                                                                                                                                        namespace TextDocumentIdentifier {}

                                                                                                                                                                                                                                                                                                                                        function create

                                                                                                                                                                                                                                                                                                                                        create: (uri: DocumentUri) => TextDocumentIdentifier;
                                                                                                                                                                                                                                                                                                                                        • Creates a new TextDocumentIdentifier literal.

                                                                                                                                                                                                                                                                                                                                          Parameter uri

                                                                                                                                                                                                                                                                                                                                          The document's uri.

                                                                                                                                                                                                                                                                                                                                        function is

                                                                                                                                                                                                                                                                                                                                        is: (value: any) => value is TextDocumentIdentifier;

                                                                                                                                                                                                                                                                                                                                        namespace TextDocumentItem

                                                                                                                                                                                                                                                                                                                                        namespace TextDocumentItem {}
                                                                                                                                                                                                                                                                                                                                        • The TextDocumentItem namespace provides helper functions to work with TextDocumentItem literals.

                                                                                                                                                                                                                                                                                                                                        function create

                                                                                                                                                                                                                                                                                                                                        create: (
                                                                                                                                                                                                                                                                                                                                        uri: DocumentUri,
                                                                                                                                                                                                                                                                                                                                        languageId: string,
                                                                                                                                                                                                                                                                                                                                        version: integer,
                                                                                                                                                                                                                                                                                                                                        text: string
                                                                                                                                                                                                                                                                                                                                        ) => TextDocumentItem;
                                                                                                                                                                                                                                                                                                                                        • Creates a new TextDocumentItem literal.

                                                                                                                                                                                                                                                                                                                                          Parameter uri

                                                                                                                                                                                                                                                                                                                                          The document's uri.

                                                                                                                                                                                                                                                                                                                                          Parameter languageId

                                                                                                                                                                                                                                                                                                                                          The document's language identifier.

                                                                                                                                                                                                                                                                                                                                          Parameter version

                                                                                                                                                                                                                                                                                                                                          The document's version number.

                                                                                                                                                                                                                                                                                                                                          Parameter text

                                                                                                                                                                                                                                                                                                                                          The document's text.

                                                                                                                                                                                                                                                                                                                                        function is

                                                                                                                                                                                                                                                                                                                                        is: (value: any) => value is TextDocumentItem;

                                                                                                                                                                                                                                                                                                                                        namespace TextEdit

                                                                                                                                                                                                                                                                                                                                        namespace TextEdit {}
                                                                                                                                                                                                                                                                                                                                        • The TextEdit namespace provides helper function to create replace, insert and delete edits more easily.

                                                                                                                                                                                                                                                                                                                                        function del

                                                                                                                                                                                                                                                                                                                                        del: (range: Range) => TextEdit;
                                                                                                                                                                                                                                                                                                                                        • Creates a delete text edit.

                                                                                                                                                                                                                                                                                                                                          Parameter range

                                                                                                                                                                                                                                                                                                                                          The range of text to be deleted.

                                                                                                                                                                                                                                                                                                                                        function insert

                                                                                                                                                                                                                                                                                                                                        insert: (position: Position, newText: string) => TextEdit;
                                                                                                                                                                                                                                                                                                                                        • Creates an insert text edit.

                                                                                                                                                                                                                                                                                                                                          Parameter position

                                                                                                                                                                                                                                                                                                                                          The position to insert the text at.

                                                                                                                                                                                                                                                                                                                                          Parameter newText

                                                                                                                                                                                                                                                                                                                                          The text to be inserted.

                                                                                                                                                                                                                                                                                                                                        function is

                                                                                                                                                                                                                                                                                                                                        is: (value: any) => value is TextEdit;

                                                                                                                                                                                                                                                                                                                                          function replace

                                                                                                                                                                                                                                                                                                                                          replace: (range: Range, newText: string) => TextEdit;
                                                                                                                                                                                                                                                                                                                                          • Creates a replace text edit.

                                                                                                                                                                                                                                                                                                                                            Parameter range

                                                                                                                                                                                                                                                                                                                                            The range of text to be replaced.

                                                                                                                                                                                                                                                                                                                                            Parameter newText

                                                                                                                                                                                                                                                                                                                                            The new text.

                                                                                                                                                                                                                                                                                                                                          namespace uinteger

                                                                                                                                                                                                                                                                                                                                          namespace uinteger {}

                                                                                                                                                                                                                                                                                                                                            variable MAX_VALUE

                                                                                                                                                                                                                                                                                                                                            const MAX_VALUE: number;

                                                                                                                                                                                                                                                                                                                                              variable MIN_VALUE

                                                                                                                                                                                                                                                                                                                                              const MIN_VALUE: number;

                                                                                                                                                                                                                                                                                                                                                function is

                                                                                                                                                                                                                                                                                                                                                is: (value: any) => value is number;

                                                                                                                                                                                                                                                                                                                                                  namespace URI

                                                                                                                                                                                                                                                                                                                                                  namespace URI {}

                                                                                                                                                                                                                                                                                                                                                    function is

                                                                                                                                                                                                                                                                                                                                                    is: (value: any) => value is string;

                                                                                                                                                                                                                                                                                                                                                      namespace VersionedTextDocumentIdentifier

                                                                                                                                                                                                                                                                                                                                                      namespace VersionedTextDocumentIdentifier {}

                                                                                                                                                                                                                                                                                                                                                      function create

                                                                                                                                                                                                                                                                                                                                                      create: (uri: DocumentUri, version: integer) => VersionedTextDocumentIdentifier;
                                                                                                                                                                                                                                                                                                                                                      • Creates a new VersionedTextDocumentIdentifier literal.

                                                                                                                                                                                                                                                                                                                                                        Parameter uri

                                                                                                                                                                                                                                                                                                                                                        The document's uri.

                                                                                                                                                                                                                                                                                                                                                        Parameter version

                                                                                                                                                                                                                                                                                                                                                        The document's version.

                                                                                                                                                                                                                                                                                                                                                      function is

                                                                                                                                                                                                                                                                                                                                                      is: (value: any) => value is VersionedTextDocumentIdentifier;

                                                                                                                                                                                                                                                                                                                                                      namespace WorkspaceEdit

                                                                                                                                                                                                                                                                                                                                                      namespace WorkspaceEdit {}

                                                                                                                                                                                                                                                                                                                                                        function is

                                                                                                                                                                                                                                                                                                                                                        is: (value: any) => value is WorkspaceEdit;

                                                                                                                                                                                                                                                                                                                                                          namespace WorkspaceFolder

                                                                                                                                                                                                                                                                                                                                                          namespace WorkspaceFolder {}

                                                                                                                                                                                                                                                                                                                                                            function is

                                                                                                                                                                                                                                                                                                                                                            is: (value: any) => value is WorkspaceFolder;

                                                                                                                                                                                                                                                                                                                                                              namespace WorkspaceSymbol

                                                                                                                                                                                                                                                                                                                                                              namespace WorkspaceSymbol {}

                                                                                                                                                                                                                                                                                                                                                                function create

                                                                                                                                                                                                                                                                                                                                                                create: (
                                                                                                                                                                                                                                                                                                                                                                name: string,
                                                                                                                                                                                                                                                                                                                                                                kind: SymbolKind,
                                                                                                                                                                                                                                                                                                                                                                uri: DocumentUri,
                                                                                                                                                                                                                                                                                                                                                                range?: Range
                                                                                                                                                                                                                                                                                                                                                                ) => WorkspaceSymbol;
                                                                                                                                                                                                                                                                                                                                                                • Create a new workspace symbol.

                                                                                                                                                                                                                                                                                                                                                                  Parameter name

                                                                                                                                                                                                                                                                                                                                                                  The name of the symbol.

                                                                                                                                                                                                                                                                                                                                                                  Parameter kind

                                                                                                                                                                                                                                                                                                                                                                  The kind of the symbol.

                                                                                                                                                                                                                                                                                                                                                                  Parameter uri

                                                                                                                                                                                                                                                                                                                                                                  The resource of the location of the symbol.

                                                                                                                                                                                                                                                                                                                                                                  Parameter range

                                                                                                                                                                                                                                                                                                                                                                  An options range of the location.

                                                                                                                                                                                                                                                                                                                                                                  Returns

                                                                                                                                                                                                                                                                                                                                                                  A WorkspaceSymbol.

                                                                                                                                                                                                                                                                                                                                                                Package Files (1)

                                                                                                                                                                                                                                                                                                                                                                Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                No dependencies.

                                                                                                                                                                                                                                                                                                                                                                Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                No dev dependencies.

                                                                                                                                                                                                                                                                                                                                                                Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                Badge

                                                                                                                                                                                                                                                                                                                                                                To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/vscode-languageserver-types.

                                                                                                                                                                                                                                                                                                                                                                • Markdown
                                                                                                                                                                                                                                                                                                                                                                  [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/vscode-languageserver-types)
                                                                                                                                                                                                                                                                                                                                                                • HTML
                                                                                                                                                                                                                                                                                                                                                                  <a href="https://www.jsdocs.io/package/vscode-languageserver-types"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>