Type Definition for Visual Studio Code 1.89 Extension API
See https://code.visualstudio.com/api for more information

Accessibility information which controls screen reader behavior.

Namespace for authentication.

Optional options to be used when calling {@link authentication.getSession } with the flag `forceNewSession`.

Options to be used when getting an {@link AuthenticationSession } from an {@link AuthenticationProvider }.

A provider for performing authentication to a service.

An {@link Event } which fires when an {@link AuthenticationSession } is added, removed, or changed.

Basic information about an {@link AuthenticationProvider }

Options for creating an {@link AuthenticationProvider }.

Represents a session of a currently logged in user.

The information of an account associated with an {@link AuthenticationSession }.

An {@link Event } which fires when an {@link AuthenticationSession } is added, removed, or changed.

Describes pairs of strings where the close string will be automatically inserted when typing the opening string.

Contains coverage information for a branch of a {@link StatementCoverage }.

The base class of all breakpoint types.

An event describing the changes to the set of {@link Breakpoint breakpoints}.

Represents an incoming call, e.g. a caller of a method or constructor.

Represents programming constructs like functions or constructors in the context
of call hierarchy.

Represents an outgoing call, e.g. calling a getter from a method or a method from a constructor etc.

The call hierarchy provider interface describes the contract between extensions
and the call hierarchy feature which allows to browse calls and caller of function,
methods, constructor etc.

An error type that should be used to signal cancellation of an operation.

This type can be used in response to a {@link CancellationToken cancellation token}
being cancelled or when an operation is being cancelled by the
executor of that operation.

A cancellation token is passed to an asynchronous or long running
operation to request cancellation, like cancelling a request
for completion items because the user continued to type.

To get an instance of a `CancellationToken` use a
{@link CancellationTokenSource }.

A cancellation source creates and controls a {@link CancellationToken cancellation token}.

The clipboard provides read and write access to the system's clipboard.

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 {@linkcode CodeAction.edit edit} and/or a {@linkcode CodeAction.command command}. If both are supplied, the `edit` is applied first, then the command is executed.

Contains additional diagnostic information about the context in which
a {@link CodeActionProvider.provideCodeActions code action} is run.

Kind of a code action.

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

Code action kinds are used by the editor for UI elements such as the refactoring context menu. Users
can also trigger code actions with a specific kind with the `editor.action.codeAction` command.

Provides contextual actions for code. Code actions typically either fix problems or beautify/refactor code.

Code actions are surfaced to users in a few different ways:

- The [lightbulb](https://code.visualstudio.com/docs/editor/editingevolved#_code-action) feature, which shows
  a list of code actions at the current cursor position. The lightbulb's list of actions includes both quick fixes
  and refactorings.
- As commands that users can run, such as `Refactor`. Users can run these from the command palette or with keybindings.
- As source actions, such `Organize Imports`.
- {@link CodeActionKind.QuickFix Quick fixes} are shown in the problems view.
- Change applied on save by the `editor.codeActionsOnSave` setting.

Metadata about the type of code actions that a {@link CodeActionProvider } provides.

The reason why code actions were requested.

A code lens represents a {@link Command } that should be shown along with
source text, like the number of references, a way to run tests, etc.

A code lens is _unresolved_ when no command is associated to it. For performance
reasons the creation of a code lens and resolving should be done to two stages.

A code lens provider adds {@link Command commands} to source text. The commands will be shown
as dedicated horizontal lines in between the source text.

Represents a color in RGBA space.

Represents a color range from a document.

A color presentation object describes how a {@linkcode Color } should be represented as text and what
edits are required to refer to it from source code.

For some languages one color can have multiple presentations, e.g. css can represent the color red with
the constant `Red`, the hex-value `#ff0000`, or in rgba and hsla forms. In csharp other representations
apply, e.g. `System.Drawing.Color.Red`.

Represents a color theme.

Represents a color theme kind.

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.

commands.registerCommand('extension.sayHello', () => {
	window.showInformationMessage('Hello World!');
});

{
	"contributes": {
		"commands": [{
			"command": "extension.sayHello",
			"title": "Hello World"
		}]
	}
}

Namespace for dealing with commands. In short, a command is a function with a
unique identifier. The function is sometimes also called _command handler_.

Commands can be added to the editor using the {@link commands.registerCommand registerCommand}
and {@link commands.registerTextEditorCommand registerTextEditorCommand} functions. Commands
can be executed {@link commands.executeCommand manually} or from a UI gesture. Those are:

* palette - Use the `commands`-section in `package.json` to make a command show in
the [command palette](https://code.visualstudio.com/docs/getstarted/userinterface#_command-palette).
* keybinding - Use the `keybindings`-section in `package.json` to enable
[keybindings](https://code.visualstudio.com/docs/getstarted/keybindings#_advanced-customization)
for your extension.

Commands from other extensions and from the editor itself are accessible to an extension. However,
when invoking an editor command not all argument types are supported.

This is a sample that registers a command handler and adds an entry for that command to the palette. First
register a command handler with the identifier `extension.sayHello`.
```javascript
commands.registerCommand('extension.sayHello', () => {
	window.showInformationMessage('Hello World!');
});
```
Second, bind the command identifier to a title under which it will show in the palette (`package.json`).
```json
{
	"contributes": {
		"commands": [{
			"command": "extension.sayHello",
			"title": "Hello World"
		}]
	}
}
```

A comment is displayed within the editor or the Comments Panel, depending on how it is provided.

Author information of a {@link Comment }

A comment controller is able to provide {@link CommentThread comments} support to the editor and
provide users various ways to interact with comments.

Comment mode of a {@link Comment }

Represents a {@link CommentController comment controller}'s {@link CommentController.options options}.

Reactions of a {@link Comment }

Command argument for actions registered in `comments/commentThread/context`.

Describes how comments for a language work.

A collection of {@link Comment comments} representing a conversation at a particular range in a document.

Collapsible state of a {@link CommentThread comment thread}

The state of a comment thread.

Commenting range provider for a {@link CommentController comment controller}.

Contains additional information about the context in which
{@link CompletionItemProvider.provideCompletionItems completion provider} is triggered.

A completion item represents a text snippet that is proposed to complete text that is being typed.

It is sufficient to create a completion item from just a {@link CompletionItem.label label}. In that
case the completion item will replace the {@link TextDocument.getWordRangeAtPosition word}
until the cursor with the given label or {@link CompletionItem.insertText insertText}. Otherwise the
given {@link CompletionItem.textEdit edit} is used.

When selecting a completion item in the editor its defined or synthesized text edit will be applied
to *all* cursors/selections whereas {@link CompletionItem.additionalTextEdits additionalTextEdits} will be
applied as provided.

Completion item kinds.

A structured label for a {@link CompletionItem completion item}.

The completion item provider interface defines the contract between extensions and
[IntelliSense](https://code.visualstudio.com/docs/editor/intellisense).

Providers can delay the computation of the {@linkcode CompletionItem.detail detail}
and {@linkcode CompletionItem.documentation documentation} properties by implementing the
{@linkcode CompletionItemProvider.resolveCompletionItem resolveCompletionItem}-function. However, properties that
are needed for the initial sorting and filtering, like `sortText`, `filterText`, `insertText`, and `range`, must
not be changed during resolve.

Providers are asked for completions either explicitly by a user gesture or -depending on the configuration-
implicitly when typing words or trigger characters.

Completion item tags are extra annotations that tweak the rendering of a completion
item.

Represents a collection of {@link CompletionItem completion items} to be presented
in the editor.

How a {@link CompletionItemProvider completion provider} was triggered

An event describing the change in Configuration

The configuration target

Represents a custom document used by a {@linkcode CustomEditorProvider }.

Custom documents are only used within a given `CustomEditorProvider`. The lifecycle of a `CustomDocument` is
managed by the editor. When no more references remain to a `CustomDocument`, it is disposed of.

A backup for an {@linkcode CustomDocument }.

Additional information used to implement {@linkcode CustomDocumentBackup }.

Event triggered by extensions to signal to the editor that the content of a {@linkcode CustomDocument }
has changed.

Event triggered by extensions to signal to the editor that an edit has occurred on an {@linkcode CustomDocument }.

Additional information about the opening custom document.

Provider for editable custom editors that use a custom document model.

Custom editors use {@linkcode CustomDocument } as their document model instead of a {@linkcode TextDocument }.
This gives extensions full control over actions such as edit, save, and backup.

You should use this type of custom editor when dealing with binary files or more complex scenarios. For simple
text based documents, use {@linkcode CustomTextEditorProvider } instead.

Provider for readonly custom editors that use a custom document model.

Custom editors use {@linkcode CustomDocument } as their document model instead of a {@linkcode TextDocument }.

You should use this type of custom editor when dealing with binary files or more complex scenarios. For simple
text based documents, use {@linkcode CustomTextEditorProvider } instead.

Provider for text based custom editors.

Text based custom editors use a {@linkcode TextDocument } as their data model. This considerably simplifies
implementing a custom editor as it allows the editor to handle many common operations such as
undo and backup. The provider is responsible for synchronizing text changes between the webview and the `TextDocument`.

A map containing a mapping of the mime type of the corresponding transferred data.

Drag and drop controllers that implement {@link TreeDragAndDropController.handleDrag `handleDrag`} can add additional mime types to the
data transfer. These additional mime types will only be included in the `handleDrop` when the the drag was initiated from
an element in the same drag and drop controller.

A file associated with a {@linkcode DataTransferItem }.

Instances of this type can only be created by the editor and not by extensions.

Encapsulates data transferred during drag and drop operations.

Namespace for debug functionality.

A debug adapter that implements the Debug Adapter Protocol can be registered with the editor if it implements the DebugAdapter interface.

A debug adaper factory that creates {@link DebugAdapterDescriptor debug adapter descriptors}.

Represents a debug adapter executable and optional arguments and runtime options passed to it.

Options for a debug adapter executable.

Represents a debug adapter running as a Named Pipe (on Windows)/UNIX Domain Socket (on non-Windows) based server.

Represents a debug adapter running as a socket based server.

A Debug Adapter Tracker is a means to track the communication between the editor and a Debug Adapter.

A debug adaper factory that creates {@link DebugAdapterTracker debug adapter trackers}.

Configuration for a debug session.

A debug configuration provider allows to add debug configurations to the debug service
and to resolve launch configurations before they are used to start a debug session.
A debug configuration provider is registered via {@link debug.registerDebugConfigurationProvider }.

A DebugConfigurationProviderTriggerKind specifies when the `provideDebugConfigurations` method of a `DebugConfigurationProvider` is triggered.
Currently there are two situations: to provide the initial debug configurations for a newly created launch.json or
to provide dynamically generated debug configurations when the user asks for them through the UI (e.g. via the "Select and Start Debugging" command).
A trigger kind is used when registering a `DebugConfigurationProvider` with {@link debug.registerDebugConfigurationProvider }.

Represents the debug console.

Debug console mode used by debug session, see {@link DebugSessionOptions options}.

A debug session.

A custom Debug Adapter Protocol event received from a {@link DebugSession debug session}.

Options for {@link debug.startDebugging starting a debug session}.

The currently active {@link DebugConsole debug console}.
If no debug session is active, output sent to the debug console is not shown.

The currently active {@link DebugSession debug session} or `undefined`. The active debug session is the one
represented by the debug action floating window or the one currently shown in the drop down menu of the debug action floating window.
If no debug session is active, the value is `undefined`.

Contains coverage information for a declaration. Depending on the reporter
and language, this may be types such as functions, methods, or namespaces.

The declaration provider interface defines the contract between extensions and
the go to declaration feature.

Represents render options for decoration instances. See {@link DecorationOptions.renderOptions }.

Represents options for a specific decoration in a {@link TextEditorDecorationType decoration set}.

Describes the behavior of decorations when typing/editing at their edges.

Represents rendering styles for a {@link TextEditorDecorationType text editor decoration}.

The definition provider interface defines the contract between extensions and
the [go to definition](https://code.visualstudio.com/docs/editor/editingevolved#_go-to-definition)
and peek definition features.

Represents a diagnostic, such as a compiler error or warning. Diagnostic objects
are only valid in the scope of a file.

The event that is fired when diagnostics change.

A diagnostics collection is a container that manages a set of
{@link Diagnostic diagnostics}. Diagnostics are always scopes to a
diagnostics collection and a resource.

To get an instance of a `DiagnosticCollection` use
{@link languages.createDiagnosticCollection createDiagnosticCollection}.

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.

Represents the severity of diagnostics.

Additional metadata about the type of a diagnostic.

Represents a type which can release resources, such
as event listening or a timer.

The document color provider defines the contract between extensions and feature of
picking and modifying colors in the editor.

An edit operation applied {@link DocumentDropEditProvider on drop}.

Provider which handles dropping of resources into a text editor.

This allows users to drag and drop resources (including resources from external apps) into the editor. While dragging
and dropping files, users can hold down `shift` to drop the file into the editor instead of opening it.
Requires `editor.dropIntoEditor.enabled` to be on.

A document filter denotes a document by different properties like
the {@link TextDocument.languageId language}, the {@link Uri.scheme scheme} of
its resource, or a glob-pattern that is applied to the {@link TextDocument.fileName path}.

The document formatting provider interface defines the contract between extensions and
the formatting-feature.

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.

A document highlight kind.

The document highlight provider interface defines the contract between extensions and
the word-highlight-feature.

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.

The document link provider defines the contract between extensions and feature of showing
links in the editor.

The document formatting provider interface defines the contract between extensions and
the formatting-feature.

The document range semantic tokens provider interface defines the contract between extensions and
semantic tokens.

The document semantic tokens provider interface defines the contract between extensions and
semantic tokens.

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.

The document symbol provider interface defines the contract between extensions and
the [go to symbol](https://code.visualstudio.com/docs/editor/editingevolved#_go-to-symbol)-feature.

Metadata about a document symbol provider.

Represents an end of line character sequence in a {@link TextDocument document}.

Describes what to do when pressing Enter.

Namespace describing the environment the editor runs in.

The system clipboard.

A collection of mutations that an extension can apply to a process environment.

A type of mutation and its value to be applied to an environment variable.

Options applied to the mutator.

A type of mutation that can be applied to an environment variable.

The scope object to which the environment variable collection applies.

An EvaluatableExpression represents an expression in a document that can be evaluated by an active debugger or runtime.
The result of this evaluation is shown in a tooltip-like widget.
If only a range is specified, the expression will be extracted from the underlying document.
An optional expression can be used to override the extracted expression.
In this case the range is still used to highlight the range in the document.

The evaluatable expression provider interface defines the contract between extensions and
the debug hover. In this contract the provider returns an evaluatable expression for a given position
in a document and the editor evaluates this expression in the active debug session and shows the result in a debug hover.

An event emitter can be used to create and manage an {@link Event } for others
to subscribe to. One emitter always owns one event.

Use this class if you want to provide event from within your extension, for instance
inside a {@link TextDocumentContentProvider } or when providing
API to other extensions.

Represents an extension.

To get an instance of an `Extension` use {@link extensions.getExtension getExtension}.

An extension context is a collection of utilities private to an
extension.

An instance of an `ExtensionContext` is provided as the first
parameter to the `activate`-call of an extension.

In a remote window the extension kind describes if an extension
runs where the UI (window) runs or if an extension runs remotely.

The ExtensionMode is provided on the `ExtensionContext` and indicates the
mode the specific extension is running in.

Value-object describing what options a virtual process terminal should use.

export function activate(context: vscode.ExtensionContext) {
	let api = {
		sum(a, b) {
			return a + b;
		},
		mul(a, b) {
			return a * b;
		}
	};
	// 'export' public api-surface
	return api;
}

let mathExt = extensions.getExtension('genius.math');
let importedApi = mathExt.exports;

console.log(importedApi.mul(42, 1));

Namespace for dealing with installed extensions. Extensions are represented
by an {@link Extension }-interface which enables reflection on them.

Extension writers can provide APIs to other extensions by returning their API public
surface from the `activate`-call.

```javascript
export function activate(context: vscode.ExtensionContext) {
	let api = {
		sum(a, b) {
			return a + b;
		},
		mul(a, b) {
			return a * b;
		}
	};
	// 'export' public api-surface
	return api;
}
```
When depending on the API of another extension add an `extensionDependencies`-entry
to `package.json`, and use the {@link extensions.getExtension getExtension}-function
and the {@link Extension.exports exports}-property, like below:

```javascript
let mathExt = extensions.getExtension('genius.math');
let importedApi = mathExt.exports;

console.log(importedApi.mul(42, 1));
```

The event filesystem providers must use to signal a file change.

Enumeration of file change types.

Contains coverage metadata for a file.

An event that is fired after files are created.

A file decoration represents metadata that can be rendered with a file.

The decoration provider interfaces defines the contract between extensions and
file decorations.

An event that is fired after files are deleted.

Permissions of a file.

An event that is fired after files are renamed.

The `FileStat`-type represents metadata about a file

The file system interface exposes the editor's built-in and contributed
{@link FileSystemProvider file system providers}. It allows extensions to work
with files from the local disk as well as files from remote places, like the
remote extension host or ftp-servers.

*Note* that an instance of this interface is available as {@linkcode workspace.fs }.

A type that filesystem providers should use to signal errors.

This class has factory methods for common error-cases, like `FileNotFound` when
a file or folder doesn't exist, use them like so: `throw vscode.FileSystemError.FileNotFound(someUri);`

The filesystem provider defines what the editor needs to read, write, discover,
and to manage files and folders. It allows extensions to serve files from remote places,
like ftp-servers, and to seamlessly integrate those into the editor.

* *Note 1:* The filesystem provider API works with {@link Uri uris} and assumes hierarchical
paths, e.g. `foo:/my/path` is a child of `foo:/my/` and a parent of `foo:/my/path/deeper`.
* *Note 2:* There is an activation event `onFileSystem:<scheme>` that fires when a file
or folder is being accessed.
* *Note 3:* The word 'file' is often used to denote all {@link FileType kinds} of files, e.g.
folders, symbolic links, and regular files.

A file system watcher notifies about changes to files and folders
on disk or from other {@link FileSystemProvider FileSystemProviders}.

To get an instance of a `FileSystemWatcher` use
{@link workspace.createFileSystemWatcher createFileSystemWatcher}.

Enumeration of file types. The types `File` and `Directory` can also be
a symbolic links, in that case use `FileType.File | FileType.SymbolicLink` and
`FileType.Directory | FileType.SymbolicLink`.

An event that is fired when files are going to be created.

To make modifications to the workspace before the files are created,
call the {@linkcode FileWillCreateEvent.waitUntil waitUntil}-function with a
thenable that resolves to a {@link WorkspaceEdit workspace edit}.

An event that is fired when files are going to be deleted.

To make modifications to the workspace before the files are deleted,
call the {@link FileWillCreateEvent.waitUntil `waitUntil`}-function with a
thenable that resolves to a {@link WorkspaceEdit workspace edit}.

An event that is fired when files are going to be renamed.

To make modifications to the workspace before the files are renamed,
call the {@link FileWillCreateEvent.waitUntil `waitUntil`}-function with a
thenable that resolves to a {@link WorkspaceEdit workspace edit}.

A line based folding range. To be valid, start and end line must be bigger than zero and smaller than the number of lines in the document.
Invalid ranges will be ignored.

An enumeration of specific folding range kinds. The kind is an optional field of a {@link FoldingRange }
and is used to distinguish specific folding ranges such as ranges originated from comments. The kind is used by commands like
`Fold all comments` or `Fold all regions`.
If the kind is not set on the range, the range originated from a syntax element other than comments, imports or region markers.

The folding range provider interface defines the contract between extensions and
[Folding](https://code.visualstudio.com/docs/editor/codebasics#_folding) in the editor.

Value-object describing what options formatting should use.

A breakpoint specified by a function name.

A collection of mutations that an extension can apply to a process environment. Applies to all scopes.

A hover represents additional information for a symbol or word. Hovers are
rendered in a tooltip-like widget.

The hover provider interface defines the contract between extensions and
the [hover](https://code.visualstudio.com/docs/editor/intellisense)-feature.

The implementation provider interface defines the contract between extensions and
the go to implementation feature.

Describes what to do with the indentation when pressing Enter.

Describes indentation rules for a language.

Inlay hint information.

Inlay hint kinds.

The kind of an inline hint defines its appearance, e.g the corresponding foreground and background colors are being
used.

An inlay hint label part allows for interactive and composite labels of inlay hints.

The inlay hints provider interface defines the contract between extensions and
the inlay hints feature.

Provides information about the context in which an inline completion was requested.

An inline completion item represents a text snippet that is proposed inline to complete text that is being typed.

The inline completion item provider interface defines the contract between extensions and
the inline completion feature.

Providers are asked for completions either explicitly by a user gesture or implicitly when typing.

Represents a collection of {@link InlineCompletionItem inline completion items} to be presented
in the editor.

Describes how an {@link InlineCompletionItemProvider inline completion provider} was triggered.

A value-object that contains contextual information when requesting inline values from a InlineValuesProvider.

Provide an inline value through an expression evaluation.
If only a range is specified, the expression will be extracted from the underlying document.
An optional expression can be used to override the extracted expression.

Provide inline value as text.

Provide inline value through a variable lookup.
If only a range is specified, the variable name will be extracted from the underlying document.
An optional variable name can be used to override the extracted name.

The inline values provider interface defines the contract between extensions and the editor's debugger inline values feature.
In this contract the provider returns inline value information for a given document range
and the editor shows this information in the editor at the end of lines.

A concrete {@link QuickInput } to let the user input a text value.

Note that in many cases the more convenient {@link window.showInputBox }
is easier to use. {@link window.createInputBox } should be used
when {@link window.showInputBox } does not offer the required flexibility.

Options to configure the behavior of the input box UI.

Object to configure the behavior of the validation message.

The severity level for input box validation.

Namespace for localization-related functionality in the extension API. To use this properly,
you must have `l10n` defined in your extension manifest and have bundle.l10n.<language>.json files.
For more information on how to generate bundle.l10n.<language>.json files, check out the
[vscode-l10n repo](https://github.com/microsoft/vscode-l10n).

Note: Built-in extensions (for example, Git, TypeScript Language Features, GitHub Authentication)
are excluded from the `l10n` property requirement. In other words, they do not need to specify
a `l10n` in the extension manifest because their translated strings come from Language Packs.

The URI of the localization bundle that has been loaded for the extension.
It's undefined if no bundle has been loaded. The bundle is typically not loaded if
there was no bundle found or when we are running with the default language.

The language configuration interfaces defines the contract between extensions
and various editor features, like automatic bracket insertion, automatic indentation etc.

A language status item is the preferred way to present language status reports for the active text editors,
such as selected linter or notifying about a configuration problem.

Represents the severity level of a language status.

languages.registerHoverProvider('javascript', {
	provideHover(document, position, token) {
		return new Hover('I am a hover!');
	}
});

Namespace for participating in language-specific editor [features](https://code.visualstudio.com/docs/editor/editingevolved),
like IntelliSense, code actions, diagnostics etc.

Many programming languages exist and there is huge variety in syntaxes, semantics, and paradigms. Despite that, features
like automatic word-completion, code navigation, or code checking have become popular across different tools for different
programming languages.

The editor provides an API that makes it simple to provide such common features by having all UI and actions already in place and
by allowing you to participate by providing data only. For instance, to contribute a hover all you have to do is provide a function
that can be called with a {@link TextDocument } and a {@link Position } returning hover info. The rest, like tracking the
mouse, positioning the hover, keeping the hover stable etc. is taken care of by the editor.

```javascript
languages.registerHoverProvider('javascript', {
	provideHover(document, position, token) {
		return new Hover('I am a hover!');
	}
});
```

Registration is done using a {@link DocumentSelector document selector} which is either a language id, like `javascript` or
a more complex {@link DocumentFilter filter} like `{ language: 'typescript', scheme: 'file' }`. Matching a document against such
a selector will result in a {@link languages.match score} that is used to determine if and how a provider shall be used. When
scores are equal the provider that came last wins. For features that allow full arity, like {@link languages.registerHoverProvider hover},
the score is only checked to be `>0`, for other features, like {@link languages.registerCompletionItemProvider IntelliSense} the
score is used for determining the order in which providers are asked to participate.

The linked editing range provider interface defines the contract between extensions and
the linked editing feature.

Represents a list of ranges that can be edited together along with a word pattern to describe valid range contents.

Represents a location inside a resource, such as a line
inside a text file.

Represents the connection of two locations. Provides additional metadata over normal {@link Location locations},
including an origin range.

Log levels

A channel for containing log output.

To get an instance of a `LogOutputChannel` use
{@link window.createOutputChannel createOutputChannel}.

Human-readable text that supports formatting via the [markdown syntax](https://commonmark.org).

Rendering of {@link ThemeIcon theme icons} via the `$(<name>)`-syntax is supported
when the {@linkcode supportThemeIcons } is set to `true`.

Rendering of embedded html is supported when {@linkcode supportHtml } is set to `true`.

A memento represents a storage utility. It can store and retrieve
values.

Represents an action that is shown with an information, warning, or
error message.

Options to configure the behavior of the message.

Represents a cell of a {@link NotebookDocument notebook}, either a {@link NotebookCellKind.Code code}-cell
or {@link NotebookCellKind.Markup markup}-cell.

NotebookCell instances are immutable and are kept in sync for as long as they are part of their notebook.

NotebookCellData is the raw representation of notebook cells. Its is part of {@linkcode NotebookData }.

A NotebookCellExecution is how {@link NotebookController notebook controller} modify a notebook cell as
it is executing.

When a cell execution object is created, the cell enters the {@linkcode NotebookCellExecutionState.Pending Pending} state.
When {@linkcode NotebookCellExecution.start start(...)} is called on the execution task, it enters the {@linkcode NotebookCellExecutionState.Executing Executing} state. When
{@linkcode NotebookCellExecution.end end(...)} is called, it enters the {@linkcode NotebookCellExecutionState.Idle Idle} state.

The summary of a notebook cell execution.

A notebook cell kind.

Notebook cell output represents a result of executing a cell. It is a container type for multiple
{@link NotebookCellOutputItem output items} where contained items represent the same result but
use different MIME types.

One representation of a {@link NotebookCellOutput notebook output}, defined by MIME type and data.

Represents the alignment of status bar items.

A contribution to a cell's status bar

A provider that can contribute items to the status bar that appears below a cell's editor.

A notebook controller represents an entity that can execute notebook cells. This is often referred to as a kernel.

There can be multiple controllers and the editor will let users choose which controller to use for a certain notebook. The
{@linkcode NotebookController.notebookType notebookType}-property defines for what kind of notebooks a controller is for and
the {@linkcode NotebookController.updateNotebookAffinity updateNotebookAffinity}-function allows controllers to set a preference
for specific notebook documents. When a controller has been selected its
{@link NotebookController.onDidChangeSelectedNotebooks onDidChangeSelectedNotebooks}-event fires.

When a cell is being run the editor will invoke the {@linkcode NotebookController.executeHandler executeHandler} and a controller
is expected to create and finalize a {@link NotebookCellExecution notebook cell execution}. However, controllers are also free
to create executions by themselves.

Notebook controller affinity for notebook documents.

Raw representation of a notebook.

Extensions are responsible for creating {@linkcode NotebookData } so that the editor
can create a {@linkcode NotebookDocument }.

Represents a notebook which itself is a sequence of {@link NotebookCell code or markup cells}. Notebook documents are
created from {@link NotebookData notebook data}.

Describes a change to a notebook cell.

An event describing a transactional {@link NotebookDocument notebook} change.

Describes a structural change to a notebook document, e.g newly added and removed cells.

Notebook content options define what parts of a notebook are persisted. Note

For instance, a notebook serializer can opt-out of saving outputs and in that case the editor doesn't mark a
notebooks as {@link NotebookDocument.isDirty dirty} when its output has changed.

Represents options to configure the behavior of showing a {@link NotebookDocument notebook document} in an {@link NotebookEditor notebook editor}.

An event that is fired when a {@link NotebookDocument notebook document} will be saved.

To make modifications to the document before it is being saved, call the
{@linkcode NotebookDocumentWillSaveEvent.waitUntil waitUntil}-function with a thenable
that resolves to a {@link WorkspaceEdit workspace edit}.

A notebook edit represents edits that should be applied to the contents of a notebook.

Represents a notebook editor that is attached to a {@link NotebookDocument notebook}.
Additional properties of the NotebookEditor are available in the proposed
API, which will be finalized later.

Represents a notebook editor that is attached to a {@link NotebookDocument notebook}.

Represents an event describing the change in a {@link NotebookEditor.selections notebook editor's selections}.

Represents an event describing the change in a {@link NotebookEditor.visibleRanges notebook editor's visibleRanges}.

A notebook range represents an ordered pair of two cell indices.
It is guaranteed that start is less than or equal to end.

Renderer messaging is used to communicate with a single renderer. It's returned from {@link notebooks.createRendererMessaging }.

The notebook serializer enables the editor to open notebook files.

At its core the editor only knows a {@link NotebookData notebook data structure} but not
how that data structure is written to a file, nor how it is read from a file. The
notebook serializer bridges this gap by deserializing bytes into notebook data and
vice versa.

Namespace for notebooks.

The notebooks functionality is composed of three loosely coupled components:

1. {@link NotebookSerializer } enable the editor to open, show, and save notebooks
2. {@link NotebookController } own the execution of notebooks, e.g they create output from code cells.
3. NotebookRenderer present notebook output in the editor. They run in a separate context.

Describes a rule to be evaluated when pressing Enter.

The document formatting provider interface defines the contract between extensions and
the formatting-feature.

Options to configure the behaviour of a file open dialog.

* Note 1: On Windows and Linux, a file dialog cannot be both a file selector and a folder selector, so if you
set both `canSelectFiles` and `canSelectFolders` to `true` on these platforms, a folder selector will be shown.
* Note 2: Explicitly setting `canSelectFiles` and `canSelectFolders` to `false` is futile
and the editor then silently adjusts the options to select files.

An output channel is a container for readonly textual information.

To get an instance of an `OutputChannel` use
{@link window.createOutputChannel createOutputChannel}.

Represents different positions for rendering a decoration in an {@link DecorationRenderOptions.overviewRulerLane overview ruler}.
The overview ruler supports three lanes.

Represents a parameter of a callable-signature. A parameter can
have a label and a doc-comment.

Represents a line and character position, such as
the position of the cursor.

Position objects are __immutable__. Use the {@link Position. with with} or
{@link Position.translate translate} methods to derive new positions
from an existing position.

The execution of a task happens as an external process
without shell interaction.

Options for a process execution

Defines a generalized way of reporting progress updates.

A location in the editor at which progress information can be shown. It depends on the
location how progress is visually represented.

Value-object describing where and how progress should show.

Defines the interface of a terminal pty, enabling extensions to control a terminal.

A quick diff provider provides a {@link Uri uri} to the original state of a
modified resource. The editor will use this information to render ad'hoc diffs
within the text.

A light-weight user input UI that is initially not visible. After
configuring it through its properties the extension can make it
visible by calling {@link QuickInput.show }.

There are several reasons why this UI might have to be hidden and
the extension will be notified through {@link QuickInput.onDidHide }.
(Examples include: an explicit call to {@link QuickInput.hide },
the user pressing Esc, some other input UI opening, etc.)

A user pressing Enter or some other gesture implying acceptance
of the current state does not automatically hide this UI component.
It is up to the extension to decide whether to accept the user's input
and if the UI should indeed be hidden through a call to {@link QuickInput.hide }.

When the extension no longer needs this input UI, it should
{@link QuickInput.dispose } it to allow for freeing up
any resources associated with it.

See {@link QuickPick } and {@link InputBox } for concrete UIs.

Button for an action in a {@link QuickPick } or {@link InputBox }.

Predefined buttons for {@link QuickPick } and {@link InputBox }.

A concrete {@link QuickInput } to let the user pick an item from a
list of items of type T. The items can be filtered through a filter text field and
there is an option {@link QuickPick.canSelectMany canSelectMany} to allow for
selecting multiple items.

Note that in many cases the more convenient {@link window.showQuickPick }
is easier to use. {@link window.createQuickPick } should be used
when {@link window.showQuickPick } does not offer the required flexibility.

Represents an item that can be selected from
a list of items.

An event signaling when a button in a particular {@link QuickPickItem } was triggered.
This event does not fire for buttons in the title bar.

The kind of {@link QuickPickItem quick pick item}.

Options to configure the behavior of the quick pick UI.

A range represents an ordered pair of two positions.
It is guaranteed that {@link Range.start start}.isBeforeOrEqual({@link Range.end end})

Range objects are __immutable__. Use the {@link Range. with with},
{@link Range.intersection intersection}, or {@link Range.union union} methods
to derive new ranges from an existing range.

Value-object that contains additional information when
requesting references.

The reference provider interface defines the contract between extensions and
the [find references](https://code.visualstudio.com/docs/editor/editingevolved#_peek)-feature.

A relative pattern is a helper to construct glob patterns that are matched
relatively to a base file path. The base path can either be an absolute file
path as string or uri or a {@link WorkspaceFolder workspace folder}, which is the
preferred way of creating the relative pattern.

The rename provider interface defines the contract between extensions and
the [rename](https://code.visualstudio.com/docs/editor/editingevolved#_rename-symbol)-feature.

Run options for a task.

Options to configure the behaviour of a file save dialog.

Namespace for source control mangement.

The {@link SourceControlInputBox input box} for the last source control
created by the extension.

Represents a storage utility for secrets, information that is
sensitive.

The event data that is fired when a secret is added or removed.

Describes the currently selected completion item.

Represents a text selection in an editor.

A selection range represents a part of a selection hierarchy. A selection range
may have a parent selection range that contains it.

The selection range provider interface defines the contract between extensions and the "Expand and Shrink Selection" feature.

Represents semantic tokens, either in a range or in an entire document.

A semantic tokens builder can help with creating a `SemanticTokens` instance
which contains delta encoded semantic tokens.

Represents an edit to semantic tokens.

Represents edits to semantic tokens.

A semantic tokens legend contains the needed information to decipher
the integer encoded representation of semantic tokens.

Represents a task execution that happens inside a shell.

Options for a shell execution

A string that will be quoted depending on the used shell.

Defines how an argument should be quoted if it contains
spaces or unsupported characters.

The shell quoting options.

Signature help represents the signature of something
callable. There can be multiple signatures but only one
active and only one active parameter.

Additional information about the context in which a
{@linkcode SignatureHelpProvider.provideSignatureHelp SignatureHelpProvider} was triggered.

The signature help provider interface defines the contract between extensions and
the [parameter hints](https://code.visualstudio.com/docs/editor/intellisense)-feature.

Metadata about a registered {@linkcode SignatureHelpProvider }.

How a {@linkcode SignatureHelpProvider } was triggered.

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

A snippet string 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}`. Also see
[the full snippet syntax](https://code.visualstudio.com/docs/editor/userdefinedsnippets#_create-your-own-snippets).

A snippet edit represents an interactive edit that is performed by
the editor.

*Note* that a snippet edit can always be performed as a normal {@link TextEdit text edit}.
This will happen when no matching editor is open or when a {@link WorkspaceEdit workspace edit}
contains snippet edits for multiple files. In that case only those that match the active editor
will be performed as snippet edits and the others as normal text edits.

A breakpoint specified by a source location.

An source control is able to provide {@link SourceControlResourceState resource states}
to the editor and interact with the editor in several source control related ways.

Represents the input box in the Source Control viewlet.

The decorations for a {@link SourceControlResourceState source control resource state}.
Can be independently specified for light and dark themes.

A source control resource group is a collection of
{@link SourceControlResourceState source control resource states}.

An source control resource state represents the state of an underlying workspace
resource within a certain {@link SourceControlResourceGroup source control group}.

The theme-aware decorations for a
{@link SourceControlResourceState source control resource state}.

Contains coverage information for a single statement or line.

Represents the alignment of status bar items.

A status bar item is a status bar contribution that can
show text and icons and run a command on click.

Represents information about programming constructs like variables, classes,
interfaces etc.

A symbol kind.

Symbol tags are extra annotations that tweak the rendering of a symbol.

Enumeration of commonly encountered syntax token types.

Represents a tab within a {@link TabGroup group of tabs}.
Tabs are merely the graphical representation within the editor area.
A backing editor is not a guarantee.

An event describing change to tabs.

Represents a group of tabs. A tab group itself consists of multiple tabs.

An event describing changes to tab groups.

Represents the main editor area which consists of multiple groups which contain tabs.

The tab represents a custom editor.

The tab represents a notebook.

The tabs represents two notebooks in a diff configuration.

The tab represents a single text based resource.

The tab represents two text based resources
being rendered as a diff.

The tab represents a webview.

A task to execute

A structure that defines a task kind in the system.
The value must be JSON-stringifyable.

An event signaling the end of an executed task.

This interface is not intended to be implemented.

An object representing an executed Task. It can be used
to terminate a task.

This interface is not intended to be implemented.

A task filter denotes tasks by their version and types

A grouping for tasks. The editor by default supports the
'Clean', 'Build', 'RebuildAll' and 'Test' group.

Controls how the task channel is used between tasks

Controls how the task is presented in the UI.

An event signaling the end of a process execution
triggered through a task

An event signaling the start of a process execution
triggered through a task

A task provider allows to add tasks to the task service.
A task provider is registered via {@link tasks.registerTaskProvider }.

Controls the behaviour of the terminal's visibility.

The scope of a task.

An event signaling the start of a task execution.

This interface is not intended to be implemented.

Namespace for tasks functionality.

A telemetry logger which can be used by extensions to log usage and error telementry.

A logger wraps around an {@link TelemetrySender sender} but it guarantees that
- user settings to disable or tweak telemetry are respected, and that
- potential sensitive data is removed

It also enables an "echo UI" that prints whatever data is send and it allows the editor
to forward unhandled errors to the respective extensions.

To get an instance of a `TelemetryLogger`, use
{@link env.createTelemetryLogger `createTelemetryLogger`}.

Options for creating a {@link TelemetryLogger }

const sender: vscode.TelemetrySender = {...};
const logger = vscode.env.createTelemetryLogger(sender);

// GOOD - uses the logger
logger.logUsage('myEvent', { myData: 'myValue' });

// BAD - uses the sender directly: no data cleansing, ignores user settings, no echoing to the telemetry output channel etc
sender.logEvent('myEvent', { myData: 'myValue' });

The telemetry sender is the contract between a telemetry logger and some telemetry service. **Note** that extensions must NOT
call the methods of their sender directly as the logger provides extra guards and cleaning.

```js
const sender: vscode.TelemetrySender = {...};
const logger = vscode.env.createTelemetryLogger(sender);

// GOOD - uses the logger
logger.logUsage('myEvent', { myData: 'myValue' });

// BAD - uses the sender directly: no data cleansing, ignores user settings, no echoing to the telemetry output channel etc
sender.logEvent('myEvent', { myData: 'myValue' });
```

A special value wrapper denoting a value that is safe to not clean.
This is to be used when you can guarantee no identifiable information is contained in the value and the cleaning is improperly redacting it.

An individual terminal instance within the integrated terminal.

Represents the dimensions of a terminal.

Assumes a {@link TerminalLocation } of editor and allows specifying a {@link ViewColumn } and
{@link TerminalEditorLocationOptions.preserveFocus preserveFocus } property

Terminal exit reason kind.

Represents how a terminal exited.

A link on a terminal line.

Provides information on a line in a terminal in order to provide links for it.

A provider that enables detection and handling of links within terminals.

The location of the terminal.

Value-object describing what options a terminal should use.

A terminal profile defines how a terminal will be launched.

Provides a terminal profile for the contributed terminal profile when launched via the UI or
command.

Uses the parent {@link Terminal }'s location for the terminal

Represents the state of a {@link Terminal }.

Entry point to discover and execute tests. It contains {@link TestController.items } which
are used to populate the editor UI, and is associated with
{@link TestController.createRunProfile run profiles} to allow
for tests to be executed.

A class that contains information about a covered resource. A count can
be give for lines, branches, and declarations in a file.

An item shown in the "test explorer" view.

A `TestItem` can represent either a test suite or a test itself, since
they both have similar capabilities.

Collection of test items, found in {@link TestItem.children } and
{@link TestController.items }.