vscode-languageserver-types

  • Version 3.18.0
  • Published
  • 414 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?: CodeActionDisabled;
            • 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 tags

            tags?: CodeActionTag[];
            • Tags for this code action.

              3.18.0 - proposed

            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.

              property tooltip

              tooltip?: string;
              • An optional tooltip.

                3.18.0

              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 CompletionItemApplyKinds

              interface CompletionItemApplyKinds {}
              • Specifies how fields from a completion item should be combined with those from completionList.itemDefaults.

                If unspecified, all fields will be treated as ApplyKind.Replace.

                If a field's value is ApplyKind.Replace, the value from a completion item (if provided and not null) will always be used instead of the value from completionItem.itemDefaults.

                If a field's value is ApplyKind.Merge, the values will be merged using the rules defined against each field below.

                Servers are only allowed to return applyKind if the client signals support for this via the completionList.applyKindSupport capability.

                3.18.0

              property commitCharacters

              commitCharacters?: ApplyKind;
              • Specifies whether commitCharacters on a completion will replace or be merged with those in completionList.itemDefaults.commitCharacters.

                If ApplyKind.Replace, the commit characters from the completion item will always be used unless not provided, in which case those from completionList.itemDefaults.commitCharacters will be used. An empty list can be used if a completion item does not have any commit characters and also should not use those from completionList.itemDefaults.commitCharacters.

                If ApplyKind.Merge the commitCharacters for the completion will be the union of all values in both completionList.itemDefaults.commitCharacters and the completion's own commitCharacters.

                3.18.0

              property data

              data?: ApplyKind;
              • Specifies whether the data field on a completion will replace or be merged with data from completionList.itemDefaults.data.

                If ApplyKind.Replace, the data from the completion item will be used if provided (and not null), otherwise completionList.itemDefaults.data will be used. An empty object can be used if a completion item does not have any data but also should not use the value from completionList.itemDefaults.data.

                If ApplyKind.Merge, a shallow merge will be performed between completionList.itemDefaults.data and the completion's own data using the following rules:

                - If a completion's data field is not provided (or null), the entire data field from completionList.itemDefaults.data will be used as-is. - If a completion's data field is provided, each field will overwrite the field of the same name in completionList.itemDefaults.data but no merging of nested fields within that value will occur.

                3.18.0

              interface CompletionItemDefaults

              interface CompletionItemDefaults {}
              • In many cases the items of an actual completion result share the same value for properties like commitCharacters or the range of a text edit. A completion list can therefore define item defaults which will be used if a completion item itself doesn't specify the value.

                If a completion list specifies a default value and a completion item also specifies a corresponding value, the rules for combining these are defined by applyKinds (if the client supports it), defaulting to ApplyKind.Replace.

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

                3.17.0

              property commitCharacters

              commitCharacters?: string[];
              • A default commit character set.

                3.17.0

              property data

              data?: LSPAny;
              • A default data value.

                3.17.0

              property editRange

              editRange?: Range | EditRangeWithInsertReplace;
              • A default edit range.

                3.17.0

              property insertTextFormat

              insertTextFormat?: InsertTextFormat;
              • A default insert text format.

                3.17.0

              property insertTextMode

              insertTextMode?: InsertTextMode;
              • A default insert text mode.

                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 applyKind

              applyKind?: CompletionItemApplyKinds;
              • Specifies how fields from a completion item should be combined with those from completionList.itemDefaults.

                If unspecified, all fields will be treated as ApplyKind.Replace.

                If a field's value is ApplyKind.Replace, the value from a completion item (if provided and not null) will always be used instead of the value from completionItem.itemDefaults.

                If a field's value is ApplyKind.Merge, the values will be merged using the rules defined against each field below.

                Servers are only allowed to return applyKind if the client signals support for this via the completionList.applyKindSupport capability.

                3.18.0

              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?: CompletionItemDefaults;
              • In many cases the items of an actual completion result share the same value for properties like commitCharacters or the range of a text edit. A completion list can therefore define item defaults which will be used if a completion item itself doesn't specify the value.

                If a completion list specifies a default value and a completion item also specifies a corresponding value, the rules for combining these are defined by applyKinds (if the client supports it), defaulting to ApplyKind.Replace.

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

                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 | MarkupContent;
              • The diagnostic's message. It usually appears in the user interface.

                3.18.0 - support for MarkupContent. This is guarded by the client capability textDocument.diagnostic.markupMessageSupport.

              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. To avoid interpretation mismatches when a server is used with different clients it is highly recommended that servers always provide a severity value.

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

                    To avoid ambiguities a server should use the [start, end] offset value instead of using a substring. Whether a client support this is controlled via labelOffsetSupport client capability.

                    *Note*: a label of type string should be a substring of its containing signature label. Its intended use case is to highlight the parameter label part in the SignatureInformation.label.

                  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.

                  property line

                  line: uinteger;
                  • Line position in a document (zero-based).

                  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 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 | null;
                    • The active parameter of the active signature.

                      If null, no parameter of the signature is active (for example a named argument that does not match any declared parameters). This is only valid if the client specifies the client capability textDocument.signatureHelp.noActiveParameterSupport === true

                      If omitted or the value lies outside the range of signatures[activeSignature].parameters defaults to 0 if the active signature has parameters.

                      If the active signature has no parameters it is ignored.

                      In future version of the protocol this property might become mandatory (but still nullable) to better express the active parameter if the active signature does have any.

                      Since version 3.16.0 the SignatureInformation itself provides a activeParameter property and it should be used instead of this one.

                    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 | null;
                    • The index of the active parameter.

                      If null, no parameter of the signature is active (for example a named argument that does not match any declared parameters). This is only valid if the client specifies the client capability textDocument.signatureHelp.noActiveParameterSupport === true

                      If provided (or null), this is used in place of SignatureHelp.activeParameter.

                      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 SnippetTextEdit

                    interface SnippetTextEdit {}
                    • An interactive text edit.

                      3.18.0

                    property annotationId

                    annotationId?: ChangeAnnotationIdentifier;
                    • The actual identifier of the snippet edit.

                    property range

                    range: Range;
                    • The range of the text document to be manipulated.

                    property snippet

                    snippet: StringValue;
                    • The snippet to be inserted.

                    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: LanguageKind;
                    • 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 | SnippetTextEdit)[];
                    • The edits to be applied.

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

                      3.18.0 - support for SnippetTextEdit. 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: LanguageKind;
                    • 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 | SnippetTextEdit) => 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.

                      3.18.0 - support for snippet text edits. This is usually guarded using a client capability.

                    method all

                    all: () => (TextEdit | AnnotatedTextEdit | SnippetTextEdit)[];
                    • 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.

                      3.18.0 - support for snippet 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 | LocationUriOnly;
                    • 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',
                                        label = 'label',
                                        }
                                        • 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 label

                                                        label = 'label'
                                                        • 3.18.0

                                                        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 ApplyKind

                                                                                  type ApplyKind = 1 | 2;
                                                                                  • Defines how values from a set of defaults and an individual item will be merged.

                                                                                    3.18.0

                                                                                  type ChangeAnnotationIdentifier

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

                                                                                  type CodeActionDisabled

                                                                                  type CodeActionDisabled = {
                                                                                  /**
                                                                                  * Human readable description of why the code action is currently disabled.
                                                                                  *
                                                                                  * This is displayed in the code actions UI.
                                                                                  */
                                                                                  reason: string;
                                                                                  };
                                                                                  • Captures why the code action is currently disabled.

                                                                                    3.18.0

                                                                                  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 CodeActionTag

                                                                                  type CodeActionTag = 1;

                                                                                    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 EditRangeWithInsertReplace

                                                                                                type EditRangeWithInsertReplace = {
                                                                                                insert: Range;
                                                                                                replace: Range;
                                                                                                };
                                                                                                • Edit range variant that includes ranges for insert and replace operations.

                                                                                                  3.18.0

                                                                                                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.
                                                                                                *
                                                                                                * If multiple hints have the same position, they will be shown in the order
                                                                                                * they appear in the response.
                                                                                                */
                                                                                                position: Position;
                                                                                                /**
                                                                                                * The label of this hint. A human readable string or an array of
                                                                                                * InlayHintLabelPart label parts.
                                                                                                *
                                                                                                * *Note* that neither the string nor the label part can be empty.
                                                                                                */
                                                                                                label: string | InlayHintLabelPart[];
                                                                                                /**
                                                                                                * The kind of this hint. Can be omitted in which case the client
                                                                                                * should fall back to a reasonable default.
                                                                                                */
                                                                                                kind?: InlayHintKind;
                                                                                                /**
                                                                                                * 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 InlineCompletionContext

                                                                                                  type InlineCompletionContext = {
                                                                                                  /**
                                                                                                  * Describes how the inline completion was triggered.
                                                                                                  */
                                                                                                  triggerKind: InlineCompletionTriggerKind;
                                                                                                  /**
                                                                                                  * Provides information about the currently selected item in the autocomplete widget if it is visible.
                                                                                                  */
                                                                                                  selectedCompletionInfo?: SelectedCompletionInfo;
                                                                                                  };
                                                                                                  • Provides information about the context in which an inline completion was requested.

                                                                                                    3.18.0

                                                                                                  type InlineCompletionTriggerKind

                                                                                                  type InlineCompletionTriggerKind = 1 | 2;

                                                                                                    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 could be used to extract the evaluatable expression
                                                                                                    * from the underlying document.
                                                                                                    */
                                                                                                    range: Range;
                                                                                                    /**
                                                                                                    * If specified the expression could be evaluated instead.
                                                                                                    */
                                                                                                    expression?: string;
                                                                                                    };
                                                                                                    • To compute an inline value through an expression evaluation.

                                                                                                      If only a range is specified, the expression should be extracted from the underlying document.

                                                                                                      An optional expression could be evaluated instead of 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;
                                                                                                    };
                                                                                                    • Returns inline value information as the complete text to be shown.

                                                                                                      3.17.0

                                                                                                    type InlineValueVariableLookup

                                                                                                    type InlineValueVariableLookup = {
                                                                                                    /**
                                                                                                    * The document range for which the inline value applies.
                                                                                                    *
                                                                                                    * The range could be 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;
                                                                                                    };
                                                                                                    • To compute inline value through a variable lookup.

                                                                                                      If only a range is specified, the variable name should be extracted from the underlying document.

                                                                                                      An optional variable name could be used to lookup instead of 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 LanguageKind

                                                                                                        type LanguageKind = string;

                                                                                                          type LocationUriOnly

                                                                                                          type LocationUriOnly = {
                                                                                                          uri: DocumentUri;
                                                                                                          };
                                                                                                          • Location with only uri and does not include range.

                                                                                                            3.18.0

                                                                                                          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 | MarkedStringWithLanguage;
                                                                                                              • 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 MarkedStringWithLanguage

                                                                                                              type MarkedStringWithLanguage = {
                                                                                                              language: string;
                                                                                                              value: string;
                                                                                                              };
                                                                                                              • 3.18.0

                                                                                                                Deprecated

                                                                                                                use MarkupContent instead.

                                                                                                              type MarkupKind

                                                                                                              type MarkupKind = 'plaintext' | 'markdown';

                                                                                                                type SelectedCompletionInfo

                                                                                                                type SelectedCompletionInfo = {
                                                                                                                /**
                                                                                                                * The range that will be replaced if this completion item is accepted.
                                                                                                                */
                                                                                                                range: Range;
                                                                                                                /**
                                                                                                                * The text the range will be replaced with if this completion is accepted.
                                                                                                                */
                                                                                                                text: string;
                                                                                                                };
                                                                                                                • Describes the currently selected completion item.

                                                                                                                  3.18.0

                                                                                                                type StringValue

                                                                                                                type StringValue = {
                                                                                                                /**
                                                                                                                * The kind of string value.
                                                                                                                */
                                                                                                                kind: 'snippet';
                                                                                                                /**
                                                                                                                * The snippet string.
                                                                                                                */
                                                                                                                value: string;
                                                                                                                };
                                                                                                                • 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

                                                                                                                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

                                                                                                                    type WorkspaceEditMetadata

                                                                                                                    type WorkspaceEditMetadata = {
                                                                                                                    /**
                                                                                                                    * Signal to the editor that this edit is a refactoring.
                                                                                                                    */
                                                                                                                    isRefactoring?: boolean;
                                                                                                                    };
                                                                                                                    • Additional data about a workspace edit.

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

                                                                                                                        namespace ApplyKind {}
                                                                                                                        • Defines how values from a set of defaults and an individual item will be merged.

                                                                                                                          3.18.0

                                                                                                                        variable Merge

                                                                                                                        const Merge: number;
                                                                                                                        • The value from the item will be merged with the default.

                                                                                                                          The specific rules for mergeing values are defined against each field that supports merging.

                                                                                                                        variable Replace

                                                                                                                        const Replace: number;
                                                                                                                        • The value from the individual item (if provided and not null) will be used instead of the default.

                                                                                                                        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 Notebook

                                                                                                                                      const Notebook: string;
                                                                                                                                      • Base kind for all code actions applying to the entire notebook's scope. CodeActionKinds using this should always begin with notebook.

                                                                                                                                        3.18.0

                                                                                                                                      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 RefactorMove

                                                                                                                                      const RefactorMove: string;
                                                                                                                                      • Base kind for refactoring move actions: refactor.move

                                                                                                                                        Example move actions:

                                                                                                                                        - Move a function to a new file - Move a property between classes - Move method to base class - ...

                                                                                                                                        3.18.0

                                                                                                                                      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 CodeActionTag

                                                                                                                                      namespace CodeActionTag {}
                                                                                                                                      • Code action tags are extra annotations that tweak the behavior of a code action.

                                                                                                                                        3.18.0 - proposed

                                                                                                                                      variable LLMGenerated

                                                                                                                                      const LLMGenerated: number;
                                                                                                                                      • Marks the code action as LLM-generated.

                                                                                                                                      function is

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

                                                                                                                                      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 | MarkupContent,
                                                                                                                                                                                                          severity?: DiagnosticSeverity,
                                                                                                                                                                                                          code?: integer | string,
                                                                                                                                                                                                          source?: string,
                                                                                                                                                                                                          relatedInformation?: DiagnosticRelatedInformation[]
                                                                                                                                                                                                          ) => Diagnostic;
                                                                                                                                                                                                          • Creates a new Diagnostic literal.

                                                                                                                                                                                                          function getMessageString

                                                                                                                                                                                                          getMessageString: (diagnostic: Diagnostic) => string;
                                                                                                                                                                                                          • Gets the message string of a diagnostic. If the message is already a string, it is returned as is. If the message is a MarkupContent, the value of the MarkupContent is returned. Otherwise an error is thrown.

                                                                                                                                                                                                            Parameter diagnostic

                                                                                                                                                                                                            the diagnostic to get the message string from.

                                                                                                                                                                                                            Returns

                                                                                                                                                                                                            the message string of the given diagnostic.

                                                                                                                                                                                                          function is

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

                                                                                                                                                                                                          function is3_17

                                                                                                                                                                                                          is3_17: (
                                                                                                                                                                                                          value: Diagnostic
                                                                                                                                                                                                          ) => value is Omit<Diagnostic, 'message'> & { message: string };
                                                                                                                                                                                                          • Checks whether the given diagnostic's message conforms to the 3.17.0 version of the protocol where the message is a string.

                                                                                                                                                                                                            Parameter value

                                                                                                                                                                                                            the diagnostic

                                                                                                                                                                                                            Returns

                                                                                                                                                                                                            true if the diagnostic's message is a string, false otherwise.

                                                                                                                                                                                                          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 LanguageKind

                                                                                                                                                                                                                                                          namespace LanguageKind {}
                                                                                                                                                                                                                                                          • Predefined Language kinds 3.18.0

                                                                                                                                                                                                                                                          variable ABAP

                                                                                                                                                                                                                                                          const ABAP: string;

                                                                                                                                                                                                                                                            variable BibTeX

                                                                                                                                                                                                                                                            const BibTeX: string;

                                                                                                                                                                                                                                                              variable C

                                                                                                                                                                                                                                                              const C: string;

                                                                                                                                                                                                                                                                variable Clojure

                                                                                                                                                                                                                                                                const Clojure: string;

                                                                                                                                                                                                                                                                  variable Coffeescript

                                                                                                                                                                                                                                                                  const Coffeescript: string;

                                                                                                                                                                                                                                                                    variable CPP

                                                                                                                                                                                                                                                                    const CPP: string;

                                                                                                                                                                                                                                                                      variable CSharp

                                                                                                                                                                                                                                                                      const CSharp: string;

                                                                                                                                                                                                                                                                        variable CSS

                                                                                                                                                                                                                                                                        const CSS: string;

                                                                                                                                                                                                                                                                          variable D

                                                                                                                                                                                                                                                                          const D: string;
                                                                                                                                                                                                                                                                          • 3.18.0

                                                                                                                                                                                                                                                                          variable Dart

                                                                                                                                                                                                                                                                          const Dart: string;

                                                                                                                                                                                                                                                                            variable Delphi

                                                                                                                                                                                                                                                                            const Delphi: string;
                                                                                                                                                                                                                                                                            • 3.18.0

                                                                                                                                                                                                                                                                            variable Diff

                                                                                                                                                                                                                                                                            const Diff: string;

                                                                                                                                                                                                                                                                              variable Dockerfile

                                                                                                                                                                                                                                                                              const Dockerfile: string;

                                                                                                                                                                                                                                                                                variable Elixir

                                                                                                                                                                                                                                                                                const Elixir: string;

                                                                                                                                                                                                                                                                                  variable Erlang

                                                                                                                                                                                                                                                                                  const Erlang: string;

                                                                                                                                                                                                                                                                                    variable FSharp

                                                                                                                                                                                                                                                                                    const FSharp: string;

                                                                                                                                                                                                                                                                                      variable GitCommit

                                                                                                                                                                                                                                                                                      const GitCommit: string;

                                                                                                                                                                                                                                                                                        variable GitRebase

                                                                                                                                                                                                                                                                                        const GitRebase: string;

                                                                                                                                                                                                                                                                                          variable Go

                                                                                                                                                                                                                                                                                          const Go: string;

                                                                                                                                                                                                                                                                                            variable Groovy

                                                                                                                                                                                                                                                                                            const Groovy: string;

                                                                                                                                                                                                                                                                                              variable Handlebars

                                                                                                                                                                                                                                                                                              const Handlebars: string;

                                                                                                                                                                                                                                                                                                variable Haskell

                                                                                                                                                                                                                                                                                                const Haskell: string;

                                                                                                                                                                                                                                                                                                  variable HTML

                                                                                                                                                                                                                                                                                                  const HTML: string;

                                                                                                                                                                                                                                                                                                    variable Ini

                                                                                                                                                                                                                                                                                                    const Ini: string;

                                                                                                                                                                                                                                                                                                      variable Java

                                                                                                                                                                                                                                                                                                      const Java: string;

                                                                                                                                                                                                                                                                                                        variable JavaScript

                                                                                                                                                                                                                                                                                                        const JavaScript: string;

                                                                                                                                                                                                                                                                                                          variable JavaScriptReact

                                                                                                                                                                                                                                                                                                          const JavaScriptReact: string;

                                                                                                                                                                                                                                                                                                            variable JSON

                                                                                                                                                                                                                                                                                                            const JSON: string;

                                                                                                                                                                                                                                                                                                              variable LaTeX

                                                                                                                                                                                                                                                                                                              const LaTeX: string;

                                                                                                                                                                                                                                                                                                                variable Less

                                                                                                                                                                                                                                                                                                                const Less: string;

                                                                                                                                                                                                                                                                                                                  variable Lua

                                                                                                                                                                                                                                                                                                                  const Lua: string;

                                                                                                                                                                                                                                                                                                                    variable Makefile

                                                                                                                                                                                                                                                                                                                    const Makefile: string;

                                                                                                                                                                                                                                                                                                                      variable Markdown

                                                                                                                                                                                                                                                                                                                      const Markdown: string;

                                                                                                                                                                                                                                                                                                                        variable ObjectiveC

                                                                                                                                                                                                                                                                                                                        const ObjectiveC: string;

                                                                                                                                                                                                                                                                                                                          variable ObjectiveCPP

                                                                                                                                                                                                                                                                                                                          const ObjectiveCPP: string;

                                                                                                                                                                                                                                                                                                                            variable Pascal

                                                                                                                                                                                                                                                                                                                            const Pascal: string;
                                                                                                                                                                                                                                                                                                                            • 3.18.0

                                                                                                                                                                                                                                                                                                                            variable Perl

                                                                                                                                                                                                                                                                                                                            const Perl: string;

                                                                                                                                                                                                                                                                                                                              variable Perl6

                                                                                                                                                                                                                                                                                                                              const Perl6: string;

                                                                                                                                                                                                                                                                                                                                variable PHP

                                                                                                                                                                                                                                                                                                                                const PHP: string;

                                                                                                                                                                                                                                                                                                                                  variable Plaintext

                                                                                                                                                                                                                                                                                                                                  const Plaintext: string;

                                                                                                                                                                                                                                                                                                                                    variable Powershell

                                                                                                                                                                                                                                                                                                                                    const Powershell: string;

                                                                                                                                                                                                                                                                                                                                      variable Pug

                                                                                                                                                                                                                                                                                                                                      const Pug: string;

                                                                                                                                                                                                                                                                                                                                        variable Python

                                                                                                                                                                                                                                                                                                                                        const Python: string;

                                                                                                                                                                                                                                                                                                                                          variable R

                                                                                                                                                                                                                                                                                                                                          const R: string;

                                                                                                                                                                                                                                                                                                                                            variable Razor

                                                                                                                                                                                                                                                                                                                                            const Razor: string;

                                                                                                                                                                                                                                                                                                                                              variable Ruby

                                                                                                                                                                                                                                                                                                                                              const Ruby: string;

                                                                                                                                                                                                                                                                                                                                                variable Rust

                                                                                                                                                                                                                                                                                                                                                const Rust: string;

                                                                                                                                                                                                                                                                                                                                                  variable SASS

                                                                                                                                                                                                                                                                                                                                                  const SASS: string;

                                                                                                                                                                                                                                                                                                                                                    variable Scala

                                                                                                                                                                                                                                                                                                                                                    const Scala: string;

                                                                                                                                                                                                                                                                                                                                                      variable SCSS

                                                                                                                                                                                                                                                                                                                                                      const SCSS: string;

                                                                                                                                                                                                                                                                                                                                                        variable ShaderLab

                                                                                                                                                                                                                                                                                                                                                        const ShaderLab: string;

                                                                                                                                                                                                                                                                                                                                                          variable ShellScript

                                                                                                                                                                                                                                                                                                                                                          const ShellScript: string;

                                                                                                                                                                                                                                                                                                                                                            variable SQL

                                                                                                                                                                                                                                                                                                                                                            const SQL: string;

                                                                                                                                                                                                                                                                                                                                                              variable Swift

                                                                                                                                                                                                                                                                                                                                                              const Swift: string;

                                                                                                                                                                                                                                                                                                                                                                variable TeX

                                                                                                                                                                                                                                                                                                                                                                const TeX: string;

                                                                                                                                                                                                                                                                                                                                                                  variable TypeScript

                                                                                                                                                                                                                                                                                                                                                                  const TypeScript: string;

                                                                                                                                                                                                                                                                                                                                                                    variable TypeScriptReact

                                                                                                                                                                                                                                                                                                                                                                    const TypeScriptReact: string;

                                                                                                                                                                                                                                                                                                                                                                      variable VisualBasic

                                                                                                                                                                                                                                                                                                                                                                      const VisualBasic: string;

                                                                                                                                                                                                                                                                                                                                                                        variable WindowsBat

                                                                                                                                                                                                                                                                                                                                                                        const WindowsBat: string;

                                                                                                                                                                                                                                                                                                                                                                          variable XML

                                                                                                                                                                                                                                                                                                                                                                          const XML: string;

                                                                                                                                                                                                                                                                                                                                                                            variable XSL

                                                                                                                                                                                                                                                                                                                                                                            const XSL: string;

                                                                                                                                                                                                                                                                                                                                                                              variable YAML

                                                                                                                                                                                                                                                                                                                                                                              const YAML: string;

                                                                                                                                                                                                                                                                                                                                                                                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 SnippetTextEdit

                                                                                                                                                                                                                                                                                                                                                                                                    namespace SnippetTextEdit {}

                                                                                                                                                                                                                                                                                                                                                                                                      function is

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

                                                                                                                                                                                                                                                                                                                                                                                                        namespace StringValue

                                                                                                                                                                                                                                                                                                                                                                                                        namespace StringValue {}

                                                                                                                                                                                                                                                                                                                                                                                                          function createSnippet

                                                                                                                                                                                                                                                                                                                                                                                                          createSnippet: (value: string) => StringValue;

                                                                                                                                                                                                                                                                                                                                                                                                            function isSnippet

                                                                                                                                                                                                                                                                                                                                                                                                            isSnippet: (value: any) => value is 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: LanguageKind,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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 | SnippetTextEdit)[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => 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: LanguageKind,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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>