VS Code API

An Event which fires when the global set of diagnostics changes. This is newly added and removed diagnostics.

Create a diagnostics collection.

Creates a new language status item.

Get all diagnostics for a given resource.

Get all diagnostics.

Return the identifiers of all known languages.

Compute the match between a document selector and a document. Values greater than zero mean the selector matches the document.

A match is computed according to these rules:

1. When DocumentSelector is an array, compute the match for each contained DocumentFilter or language identifier and take the maximum value.
2. A string will be desugared to become the language-part of a DocumentFilter, so "fooLang" is like { language: "fooLang" }.
3. A DocumentFilter will be matched against the document by comparing its parts with the document. The following rules apply:
   1. When the DocumentFilter is empty ({}) the result is 0
   2. When scheme, language, pattern, or notebook are defined but one doesn't match, the result is 0
   3. Matching against * gives a score of 5, matching via equality or via a glob-pattern gives a score of 10
   4. The result is the maximum value of each match

Samples:

When a new McpServerDefinitionProvider is available, the editor will, by default, automatically invoke it to discover new servers and tools when a chat message is submitted. To enable this flow, extensions should call registerMcpServerDefinitionProvider during activation.

Register a LanguageModelTool. The tool must also be registered in the package.json languageModelTools contribution point. A registered tool is available in the lm.tools list for any extension to see. But in order for it to be seen by a language model, it must be passed in the list of available tools in LanguageModelChatRequestOptions.tools.

Select chat models by a selector. This can yield multiple or no chat models and extensions must handle these cases, esp. when no chat model exists, gracefully.

Refer to https://code.visualstudio.com/docs/editor/workspaces for more information on the concept of workspaces.

Note: it is not advised to use workspace.workspaceFile to write configuration data into the file. You can use workspace.getConfiguration().update() for that purpose which will work both when a single folder is opened as well as an untitled or saved workspace.

List of workspace folders (0-N) that are open in the editor. undefined when no workspace has been opened.

Refer to https://code.visualstudio.com/docs/editor/workspaces for more information on workspaces.

An event that is emitted when the configuration changed.

An event that is emitted when a notebook has changed.

An event that is emitted when a text document is changed. This usually happens when the contents changes but also when other things like the dirty-state changes.

An event that is emitted when a workspace folder is added or removed.

Note: this event will not fire if the first workspace folder is added, removed or changed, because in that case the currently executing extensions (including the one that listens to this event) will be terminated and restarted so that the (deprecated) rootPath property is updated to point to the first workspace folder.

An event that is emitted when a notebook is disposed.

Note 1: There is no guarantee that this event fires when an editor tab is closed.

Note 2: A notebook can be open but not shown in an editor which means this event can fire for a notebook that has not been shown in an editor.

An event that is emitted when a text document is disposed or when the language id of a text document has been changed.

Note 1: There is no guarantee that this event fires when an editor tab is closed, use the onDidChangeVisibleTextEditors-event to know when editors change.

Note 2: A document can be open but not shown in an editor which means this event can fire for a document that has not been shown in an editor.

An event that is emitted when files have been created.

Note: This event is triggered by user gestures, like creating a file from the explorer, or from the workspace.applyEdit-api, but this event is not fired when files change on disk, e.g triggered by another application, or when using the workspace.fs-api.

An event that is emitted when files have been deleted.

Note 1: This event is triggered by user gestures, like deleting a file from the explorer, or from the workspace.applyEdit-api, but this event is not fired when files change on disk, e.g triggered by another application, or when using the workspace.fs-api.

Note 2: When deleting a folder with children only one event is fired.

Event that fires when the current workspace has been trusted.

An event that is emitted when a notebook is opened.

An event that is emitted when a text document is opened or when the language id of a text document has been changed.

To add an event listener when a visible text document is opened, use the TextEditor events in the window namespace. Note that:

• The event is emitted before the document is updated in the active text editor
• When a text document is already open (e.g.: open in another visible text editor) this event is not emitted

An event that is emitted when files have been renamed.

Note 1: This event is triggered by user gestures, like renaming a file from the explorer, and from the workspace.applyEdit-api, but this event is not fired when files change on disk, e.g triggered by another application, or when using the workspace.fs-api.

Note 2: When renaming a folder with children only one event is fired.

An event that is emitted when a notebook is saved.

An event that is emitted when a text document is saved to disk.

An event that is emitted when files are being created.

Note 1: This event is triggered by user gestures, like creating a file from the explorer, or from the workspace.applyEdit-api. This event is not fired when files change on disk, e.g triggered by another application, or when using the workspace.fs-api.

Note 2: When this event is fired, edits to files that are are being created cannot be applied.

An event that is emitted when files are being deleted.

Note 1: This event is triggered by user gestures, like deleting a file from the explorer, or from the workspace.applyEdit-api, but this event is not fired when files change on disk, e.g triggered by another application, or when using the workspace.fs-api.

Note 2: When deleting a folder with children only one event is fired.

An event that is emitted when files are being renamed.

Note 1: This event is triggered by user gestures, like renaming a file from the explorer, and from the workspace.applyEdit-api, but this event is not fired when files change on disk, e.g triggered by another application, or when using the workspace.fs-api.

Note 2: When renaming a folder with children only one event is fired.

An event that is emitted when a notebook document will be saved to disk.

Note 1: Subscribers can delay saving by registering asynchronous work. For the sake of data integrity the editor might save without firing this event. For instance when shutting down with dirty files.

Note 2: Subscribers are called sequentially and they can delay saving by registering asynchronous work. Protection against misbehaving listeners is implemented as such:

• there is an overall time budget that all listeners share and if that is exhausted no further listener is called
• listeners that take a long time or produce errors frequently will not be called anymore

The current thresholds are 1.5 seconds as overall time budget and a listener can misbehave 3 times before being ignored.

An event that is emitted when a text document will be saved to disk.

Note 1: Subscribers can delay saving by registering asynchronous work. For the sake of data integrity the editor might save without firing this event. For instance when shutting down with dirty files.

Note 2: Subscribers are called sequentially and they can delay saving by registering asynchronous work. Protection against misbehaving listeners is implemented as such:

• there is an overall time budget that all listeners share and if that is exhausted no further listener is called
• listeners that take a long time or produce errors frequently will not be called anymore

The current thresholds are 1.5 seconds as overall time budget and a listener can misbehave 3 times before being ignored.

Make changes to one or many resources or create, delete, and rename resources as defined by the given workspace edit.

All changes of a workspace edit are applied in the same order in which they have been added. If multiple textual inserts are made at the same position, these strings appear in the resulting text in the order the 'inserts' were made, unless that are interleaved with resource edits. Invalid sequences like 'delete file a' -> 'insert text in file a' cause failure of the operation.

When applying a workspace edit that consists only of text edits an 'all-or-nothing'-strategy is used. A workspace edit with resource creations or deletions aborts the operation, e.g. consecutive edits will not be attempted, when a single edit fails.

Returns a path that is relative to the workspace folder or folders.

When there are no workspace folders or when the path is not contained in them, the input is returned.

Creates a file system watcher that is notified on file events (create, change, delete) depending on the parameters provided.

By default, all opened workspace folders will be watched for file changes recursively.

Additional paths can be added for file watching by providing a RelativePattern with a base path to watch. If the path is a folder and the pattern is complex (e.g. contains ** or path segments), it will be watched recursively and otherwise will be watched non-recursively (i.e. only changes to the first level of the path will be reported).

Note that paths that do not exist in the file system will be monitored with a delay until created and then watched depending on the parameters provided. If a watched path is deleted, the watcher will suspend and not report any events until the path is created again.

If possible, keep the use of recursive watchers to a minimum because recursive file watching is quite resource intense.

Providing a string as globPattern acts as convenience method for watching file events in all opened workspace folders. It cannot be used to add more folders for file watching, nor will it report any file events from folders that are not part of the opened workspace folders.

Note that case-sensitivity of the globPattern parameter will depend on the file system where the watcher is running: on Windows and macOS the matching will be case-insensitive and on Linux it will be case-sensitive.

Optionally, flags to ignore certain kinds of events can be provided.

To stop listening to events the watcher must be disposed.

Note that file events from deleting a folder may not include events for the contained files. For example, when a folder is moved to the trash, only one event is reported because technically this is a rename/move operation and not a delete operation for each files within. On top of that, performance optimizations are in place to fold multiple events that all belong to the same parent operation (e.g. delete folder) into one event for that parent. As such, if you need to know about all deleted files, you have to watch with ** and deal with all file events yourself.

Note that file events from recursive file watchers may be excluded based on user configuration. The setting files.watcherExclude helps to reduce the overhead of file events from folders that are known to produce many file changes at once (such as .git folders). As such, it is highly recommended to watch with simple patterns that do not require recursive watchers where the exclude settings are ignored and you have full control over the events.

Note that symbolic links are not automatically followed for file watching unless the path to watch itself is a symbolic link.

Note that the file paths that are reported for having changed may have a different path casing compared to the actual casing on disk on case-insensitive platforms (typically macOS and Windows but not Linux). We allow a user to open a workspace folder with any desired path casing and try to preserve that. This means:

• if the path is within any of the workspace folders, the path will match the casing of the workspace folder up to that portion of the path and match the casing on disk for children
• if the path is outside of any of the workspace folders, the casing will match the case of the path that was provided for watching In the same way, symbolic links are preserved, i.e. the file event will report the path of the symbolic link as it was provided for watching and not the target.

Examples

The basic anatomy of a file watcher is as follows:

If you want to monitor file events across all opened workspace folders:

And use a complex glob pattern to watch recursively:

Decodes the content from a Uint8Array to a string. You MUST provide the entire content at once to ensure that the encoding can properly apply. Do not use this method to decode content in chunks, as that may lead to incorrect results.

Will pick an encoding based on settings and the content of the buffer (for example byte order marks).

Note that if you decode content that is unsupported by the encoding, the result may contain substitution characters as appropriate.

• throws - This method will throw an error when the content is binary.

Decodes the content from a Uint8Array to a string using the provided encoding. You MUST provide the entire content at once to ensure that the encoding can properly apply. Do not use this method to decode content in chunks, as that may lead to incorrect results.

Note that if you decode content that is unsupported by the encoding, the result may contain substitution characters as appropriate.

• throws - This method will throw an error when the content is binary.

Decodes the content from a Uint8Array to a string. You MUST provide the entire content at once to ensure that the encoding can properly apply. Do not use this method to decode content in chunks, as that may lead to incorrect results.

The encoding is picked based on settings and the content of the buffer (for example byte order marks).

Note that if you decode content that is unsupported by the encoding, the result may contain substitution characters as appropriate.

• throws - This method will throw an error when the content is binary.

Encodes the content of a string to a Uint8Array.

Will pick an encoding based on settings.

Encodes the content of a string to a Uint8Array using the provided encoding.

Encodes the content of a string to a Uint8Array.

The encoding is picked based on settings.

Find files across all workspace folders in the workspace.

Example

Example: removing the first workspace folder

It is valid to remove an existing workspace folder and add it again with a different name to rename that folder.

Note: it is not valid to call updateWorkspaceFolders() multiple times without waiting for the onDidChangeWorkspaceFolders() to fire.

Label to be read out by a screen reader once the item has focus.

Role of the widget which defines how a screen reader interacts with it. The role should be set in special cases when for example a tree-like element behaves like a checkbox. If role is not specified the editor will pick the appropriate role automatically. More about aria roles can be found here https://w3c.github.io/aria/#widget_roles

The account that you would like to get a session for. This is passed down to the Authentication Provider to be used for creating the correct session.

Whether the existing session preference should be cleared.

For authentication providers that support being signed into multiple accounts at once, the user will be prompted to select an account to use when getSession is called. This preference is remembered until getSession is called with this flag.

Note: The preference is extension specific. So if one extension calls getSession, it will not affect the session preference for another extension calling getSession. Additionally, the preference is set for the current workspace and also globally. This means that new workspaces will use the "global" value at first and then when this flag is provided, a new value can be set for that workspace. This also means that pre-existing workspaces will not lose their preference if a new workspace sets this flag.

Defaults to false.

Whether login should be performed if there is no matching session.

If true, a modal dialog will be shown asking the user to sign in. If false, a numbered badge will be shown on the accounts activity bar icon. An entry for the extension will be added under the menu to sign in. This allows quietly prompting the user to sign in.

If you provide options, you will also see the dialog but with the additional context provided.

If there is a matching session but the extension has not been granted access to it, setting this to true will also result in an immediate modal dialog, and false will add a numbered badge to the accounts icon.

Defaults to false.

Note: you cannot use this option with silent.

Whether we should attempt to reauthenticate even if there is already a session available.

If true, a modal dialog will be shown asking the user to sign in again. This is mostly used for scenarios where the token needs to be re minted because it has lost some authorization.

If you provide options, you will also see the dialog but with the additional context provided.

If there are no existing sessions and forceNewSession is true, it will behave identically to createIfNone.

This defaults to false.

Whether we should show the indication to sign in in the Accounts menu.

If false, the user will be shown a badge on the Accounts menu with an option to sign in for the extension. If true, no indication will be shown.

Defaults to false.

Note: you cannot use this option with any other options that prompt the user like createIfNone.

An optional message that will be displayed to the user when we ask to re-authenticate. Providing additional context as to why you are asking a user to re-authenticate can help increase the odds that they will accept.

An Event which fires when the array of sessions has changed, or data within a session has changed.

Prompts a user to login.

If login is successful, the onDidChangeSessions event should be fired.

If login fails, a rejected promise should be returned.

If the provider has specified that it does not support multiple accounts, then this should never be called if there is already an existing session matching these scopes.

Get a list of sessions.

Removes the session corresponding to session id.

If the removal is successful, the onDidChangeSessions event should be fired.

If a session cannot be removed, the provider should reject with an error message.

The AuthenticationSessions of the AuthenticationProvider that have been added.

The AuthenticationSessions of the AuthenticationProvider that have been changed. A session changes when its data excluding the id are updated. An example of this is a session refresh that results in a new access token being set for the session.

The AuthenticationSessions of the AuthenticationProvider that have been removed.

The unique identifier of the authentication provider.

The human-readable name of the authentication provider.

Whether it is possible to be signed into multiple accounts at once with this provider. If not specified, will default to false.

The account that is being asked about. If this is passed in, the provider should attempt to return the sessions that are only related to this account.

The access token. This token should be used to authenticate requests to a service. Popularized by OAuth.

• reference - https://oauth.net/2/access-tokens/

The account associated with the session.

The identifier of the authentication session.

The ID token. This token contains identity information about the user. Popularized by OpenID Connect.

• reference - https://openid.net/specs/openid-connect-core-1_0.html#IDToken

The permissions granted by the session's access token. Available scopes are defined by the AuthenticationProvider.

The unique identifier of the account.

The human-readable name of the account.

The AuthenticationProvider that has had its sessions change.

The fallback scopes to use if no scopes are found in the WWW-Authenticate header.

The raw WWW-Authenticate header value that triggered this challenge. This will be parsed by the authentication provider to extract the necessary challenge information.

The closing string that will be automatically inserted when typing the opening string.

A set of tokens where the pair should not be auto closed.

The string that will trigger the automatic insertion of the closing string.

The number of times this branch was executed, or a boolean indicating whether it was executed if the exact count is unknown. If zero or false, the branch will be marked as un-covered.

Label for the branch, used in the context of "the ${label} branch was not taken," for example.

Branch location.

Creates a new breakpoint

An optional expression for conditional breakpoints.

Is breakpoint enabled.

An optional expression that controls how many hits of the breakpoint are ignored.

The unique ID of the breakpoint.

An optional message that gets logged when this breakpoint is hit. Embedded expressions within {} are interpolated by the debug adapter.

Added breakpoints.

Changed breakpoints.

Removed breakpoints.

Create a new call object.

The item that makes the call.

The range at which at which the calls appears. This is relative to the caller denoted by this.from.

Creates a new call hierarchy item.

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

The kind of this item.

The name of this item.

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

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.

Tags for this item.

The resource identifier of this item.

Create a new call object.

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

The item that is called.

Bootstraps call hierarchy by returning the item that is denoted by the given document and position. This item will be used as entry into the call graph. Providers should return undefined or null when there is no item at the given location.

Provide all incoming calls for an item, e.g all callers for a method. In graph terms this describes directed and annotated edges inside the call graph, e.g the given item is the starting node and the result is the nodes that can be reached.

Provide all outgoing calls for an item, e.g call calls to functions, methods, or constructors from the given item. In graph terms this describes directed and annotated edges inside the call graph, e.g the given item is the starting node and the result is the nodes that can be reached.

Creates a new cancellation error.

Is true when the token has been cancelled, false otherwise.

An Event which fires upon cancellation.

The cancellation token of this source.

Signal cancellation on the token.

Dispose object and free resources.

All of the chat messages so far in the current chat session. Currently, only chat messages for the current participant are included.

An error message that is shown to the user.

If set to true, the response will be partly blurred out.

By default, the followup goes to the same participant/command. But this property can be set to invoke a different command.

A title to show the user. The prompt will be shown by default, when this is unspecified.

By default, the followup goes to the same participant/command. But this property can be set to invoke a different participant by ID. Followups can only invoke a participant that was contributed by the same extension.

The message to send to the chat.

Provide followups for the given result.

The tool name. Refers to a tool listed in lm.tools.

The start and end index of the reference in the prompt. When undefined, the reference was not part of the prompt text.

Note that the indices take the leading #-character into account which means they can be used to modify the prompt as-is.

An event that fires whenever feedback for a result is received, e.g. when a user up- or down-votes a result.

The passed result is guaranteed to have the same properties as the result that was previously returned from this chat participant's handler.

This provider will be called once after each request to retrieve suggested followup questions.

An icon for the participant shown in UI.

A unique ID for this participant.

The handler for requests to this participant.

Dispose this participant and free resources.

A unique identifier for this kind of reference.

A description of this value that could be used in an LLM prompt.

The start and end index of the reference in the prompt. When undefined, the reference was not part of the prompt text.

Note that the indices take the leading #-character into account which means they can used to modify the prompt as-is.

The value of this reference. The string | Uri | Location types are used today, but this could expand in the future.

The name of the [ChatCommand command](#_ChatCommand command) that was selected for this request.

This is the model that is currently selected in the UI. Extensions can use this or use lm.selectChatModels to pick another model. Don't hold onto this past the lifetime of the request.

The prompt as entered by the user.

Information about references used in this request is stored in ChatRequest.references.

Note that the [ChatParticipant.name name](#_ChatParticipant.name name) of the participant and the [ChatCommand.name command](#_ChatCommand.name command) are not part of the prompt.

The list of references and their values that are referenced in the prompt.

Note that the prompt contains references as authored and that it is up to the participant to further modify the prompt, for instance by inlining reference values or creating links to headings which contain the resolved values. References are sorted in reverse by their range in the prompt. That means the last reference in the prompt is the first in this list. This simplifies string-manipulation of the prompt.

A token that can be passed to lm.invokeTool when invoking a tool inside the context of handling a chat request. This associates the tool invocation to a chat session.

The list of tools that the user attached to their request.

When a tool reference is present, the chat participant should make a chat request using LanguageModelChatToolMode.Required to force the language model to generate input for the tool. Then, the participant can use lm.invokeTool to use the tool attach the result to its request for the user's prompt. The tool may contribute useful extra context for the user's request.

The name of the [ChatCommand command](#_ChatCommand command) that was selected for this request.

The id of the chat participant to which this request was directed.

The prompt as entered by the user.

Information about references used in this request is stored in ChatRequestTurn.references.

Note that the [ChatParticipant.name name](#_ChatParticipant.name name) of the participant and the [ChatCommand.name command](#_ChatCommand.name command) are not part of the prompt.

The references that were used in this message.

The list of tools were attached to this request.

Create a new ChatResponseAnchorPart.

An optional title that is rendered with value.

The target of this anchor.

Create a new ChatResponseCommandButtonPart.

The command that will be executed when the button is clicked.

An array of child file trees, if the current file tree is a directory.

The name of the file or directory.

Create a new ChatResponseFileTreePart.

The base uri to which this file tree is relative

File tree data.

Create a new ChatResponseMarkdownPart.

A markdown string or a string that should be interpreted as markdown.

Create a new ChatResponseProgressPart.

The progress message

Create a new ChatResponseReferencePart.

The icon for the reference.

The reference target.

Push an anchor part to this stream. Short-hand for push(new ChatResponseAnchorPart(value, title)). An anchor is an inline reference to some type of resource.

Push a command button part to this stream. Short-hand for push(new ChatResponseCommandButtonPart(value, title)).

Push a filetree part to this stream. Short-hand for push(new ChatResponseFileTreePart(value)).

Push a markdown part to this stream. Short-hand for push(new ChatResponseMarkdownPart(value)).

See also ChatResponseStream.push

Push a progress part to this stream. Short-hand for push(new ChatResponseProgressPart(value)).

Pushes a part to this stream.

Push a reference to this stream. Short-hand for push(new ChatResponseReferencePart(value)).

Note that the reference is not rendered inline with the response.

The name of the command that this response came from.

The id of the chat participant that this response came from.

The content that was received from the chat participant. Only the stream parts that represent actual content (not metadata) are represented.

The result that was received from the chat participant.

If the request resulted in an error, this property defines the error details.

Arbitrary metadata for this result. Can be anything, but must be JSON-stringifyable.

The kind of feedback that was received.

The ChatResult for which the user is providing feedback. This object has the same properties as the result returned from the participant callback, including metadata, but is not the same instance.

The user marked the result as unhelpful.

The user marked the result as helpful.

Read the current clipboard contents as text.

Writes text into the clipboard.

Creates a new code action.

A code action must have at least a title and edits and/or a command.

A Command this code action executes.

If this command throws an exception, the editor displays the exception message to users in the editor at the current cursor position.

Diagnostics that this code action resolves.

Marks that the code action cannot currently be applied.

• Disabled code actions are not shown in automatic lightbulb code action menu.

• Disabled actions are shown as faded out in the code action menu when the user request a more specific type of code action, such as refactorings.

• If the user has a keybinding that auto applies a code action and only a disabled code actions are returned, the editor will show the user an error message with reason in the editor.

A workspace edit this code action performs.

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.

Kind of the code action.

Used to filter code actions.

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

An array of diagnostics.

Requested kind of actions to return.

Actions not of this kind are filtered out before being shown by the lightbulb.

The reason why code actions were requested.

Empty kind.

Base kind for all code actions applying to the entire notebook's scope. CodeActionKinds using this should always begin with notebook.

This requires that new CodeActions be created for it and contributed via extensions. Pre-existing kinds can not just have the new notebook. prefix added to them, as the functionality is unique to the full-notebook scope.

Notebook CodeActionKinds can be initialized as either of the following (both resulting in notebook.source.xyz):

• const newKind = CodeActionKind.Notebook.append(CodeActionKind.Source.append('xyz').value)
• const newKind = CodeActionKind.Notebook.append('source.xyz')

Example Kinds/Actions:

• notebook.source.organizeImports (might move all imports to a new top cell)
• notebook.source.normalizeVariableNames (might rename all variables to a standardized casing format)

Base kind for quickfix actions: quickfix.

Quick fix actions address a problem in the code and are shown in the normal code action context menu.

Base kind for refactoring actions: refactor

Refactoring actions are shown in the refactoring context menu.

Base kind for refactoring extraction actions: refactor.extract

Example extract actions:

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

Base kind for refactoring inline actions: refactor.inline

Example inline actions:

• Inline function
• Inline variable
• Inline constant
• ...

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

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

Base kind for source actions: source

Source code actions apply to the entire file. They must be explicitly requested and will not show in the normal lightbulb menu. Source actions can be run on save using editor.codeActionsOnSave and are also shown in the source context menu.

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.

Base kind for an organize imports source action: source.organizeImports.

Private constructor, use static CodeActionKind.XYZ to derive from an existing code action kind.

String value of the kind, e.g. "refactor.extract.function".

Create a new kind by appending a more specific selector to the current kind.

Does not modify the current kind.

Checks if other is a sub-kind of this CodeActionKind.

The kind "refactor.extract" for example contains "refactor.extract" and ``"refactor.extract.function", but not "unicorn.refactor.extract", or "refactor.extractAll"orrefactor`.

Checks if this code action kind intersects other.

The kind "refactor.extract" for example intersects refactor, "refactor.extract" and "refactor.extract.function", but not "unicorn.refactor.extract", or "refactor.extractAll".

Get code actions for a given range in a document.

Only return code actions that are relevant to user for the requested range. Also keep in mind how the returned code actions will appear in the UI. The lightbulb widget and Refactor commands for instance show returned code actions as a list, so do not return a large number of code actions that will overwhelm the user.

Given a code action fill in its edit-property. Changes to all other properties, like title, are ignored. A code action that has an edit will not be resolved.

Note that a code action provider that returns commands, not code actions, cannot successfully implement this function. Returning commands is deprecated and instead code actions should be returned.

Static documentation for a class of code actions.

Documentation from the provider is shown in the code actions menu if either:

• Code actions of kind are requested by the editor. In this case, the editor will show the documentation that most closely matches the requested code action kind. For example, if a provider has documentation for both Refactor and RefactorExtract, when the user requests code actions for RefactorExtract, the editor will use the documentation for RefactorExtract instead of the documentation for Refactor.

• Any code actions of kind are returned by the provider.

At most one documentation entry will be shown per provider.

List of CodeActionKinds that a CodeActionProvider may return.

This list is used to determine if a given CodeActionProvider should be invoked or not. To avoid unnecessary computation, every CodeActionProvider should list use providedCodeActionKinds. The list of kinds may either be generic, such as [CodeActionKind.Refactor], or list out every kind provided, such as [CodeActionKind.Refactor.Extract.append('function'), CodeActionKind.Refactor.Extract.append('constant'), ...].

Code actions were explicitly requested by the user or by an extension.

Code actions were requested automatically.

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

Creates a new code lens object.

The command this code lens represents.

true when there is a command associated.

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

An optional event to signal that the code lenses from this provider have changed.

Compute a list of lenses. This call should return as fast as possible and if computing the commands is expensive implementors should only return code lens objects with the range set and implement resolve.

This function will be called for each visible code lens, usually when scrolling and after calls to compute-lenses.

Creates a new color instance.

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

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

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

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

Creates a new color range.

The actual color value for this color range.

The range in the document where this color appears.

Creates a new color presentation.

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

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.

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

The kind of this color theme: light, dark, high contrast dark and high contrast light.

A light color theme.

A dark color theme.

A dark high contrast color theme.

A light high contrast color theme.

Arguments that the command handler should be invoked with.

The identifier of the actual command handler.

See also commands.registerCommand

Title of the command, like save.

A tooltip for the command, when represented in the UI.

The author information of the comment

The human-readable comment body

Context value of the comment. This can be used to contribute comment specific actions. For example, a comment is given a context value as editable. When contributing actions to comments/comment/title using menus extension point, you can specify context value for key comment in when expression like comment == editable.

This will show action extension.deleteCommentThread only for comment threads with contextValue is editable.

The optional human-readable label describing the Comment Thread

The range the comment thread is located within the document. The thread icon will be shown at the last line of the range. When set to undefined, the comment will be associated with the file, and not a specific range.

The optional state of a comment thread, which may affect how the comment is displayed.

The uri of the document the thread has been created on.

Dispose this comment thread.

Once disposed, this comment thread will be removed from visible editors and Comment Panel when appropriate.

Determines an item is collapsed

Determines an item is expanded

Unresolved thread state

Resolved thread state

Character that triggered the completion item provider.

undefined if the provider was not triggered by a character.

The trigger character is already in the document when the completion provider is triggered.

How the completion was triggered.

Creates a new completion item.

Completion items must have at least a label which then will be used as insert text as well as for sorting and filtering.

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

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

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.

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

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

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

Note that the filter text is matched against the leading word (prefix) which is defined by the range-property.

A string or snippet that should be inserted in a document when selecting this completion. When falsy the label is used.

Keep whitespace of the insertText as is. By default, the editor adjusts leading whitespace of new lines so that they match the indentation of the line for which the item is accepted - setting this to true will prevent that.

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

The label of this completion item. By default this is also the text that is inserted when selecting this completion.

Select this item when showing. Note that only one completion item can be selected and that the editor decides which item that is. The rule is that the first item of those that match best is selected.

A range or a insert and replace range selecting the text that should be replaced by this completion item.

When omitted, the range of the current word is used as replace-range and as insert-range the start of the current word to the current position is used.

Note 1: A range must be a single line and it must contain the position at which completion has been requested. Note 2: A insert range must be a prefix of a replace range, that means it must be contained and starting at the same position.

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

Note that sortText is only used for the initial ordering of completion items. When having a leading word (prefix) ordering is based on how well completions match that prefix and the initial ordering is only used when completions match equally well. The prefix is defined by the range-property and can therefore be different for each completion.

Tags for this completion item.

• deprecated - Use CompletionItem.insertText and CompletionItem.range instead.

An edit which is applied to a document when selecting this completion. When an edit is provided the value of insertText is ignored.

The Range of the edit must be single-line and on the same line completions were requested at.

The Text completion item kind.

The Method completion item kind.

The Function completion item kind.

The Constructor completion item kind.

The Field completion item kind.

The Variable completion item kind.

The Class completion item kind.

The Interface completion item kind.

The Module completion item kind.

The Property completion item kind.

The Unit completion item kind.

The Value completion item kind.

The Enum completion item kind.

The Keyword completion item kind.

The Snippet completion item kind.

The Color completion item kind.

The File completion item kind.

The Reference completion item kind.

The Folder completion item kind.

The EnumMember completion item kind.

The Constant completion item kind.

The Struct completion item kind.

The Event completion item kind.

The Operator completion item kind.

The TypeParameter completion item kind.

The User completion item kind.

The Issue completion item kind.

An optional string which is rendered less prominently after CompletionItemLabel.detail. Should be used for fully qualified names or file path.

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

The label of this completion item.

By default this is also the text that is inserted when this completion is selected.

Provide completion items for the given position and document.

Given a completion item fill in more data, like doc-comment or details.

The editor will only resolve a completion item once.

Note that this function is called when completion items are already showing in the UI or when an item has been selected for insertion. Because of that, no property that changes the presentation (label, sorting, filtering etc) or the (primary) insert behaviour (insertText) can be changed.

This function may fill in additionalTextEdits. However, that means an item might be inserted before resolving is done and in that case the editor will do a best effort to still apply those additional text edits.