1/21/26, 2:23 PM VS Code API | Visual Studio Code Extension API

Version 1.108 (/updates) is now available! Read about the new features and fixes from December. ×
TOPICS VS Code API

VS Code API
VS Code API is a set of JavaScript APIs that you can invoke in your Visual Studio Code extension. This page
lists all VS Code APIs available to extension authors.
API namespaces and classes
This listing is compiled from the [Link] ([Link]
dts/[Link]) file from the VS Code repository.
authentication
Namespace for authentication.
Events
onDidChangeSessions: Event<AuthenticationSessionsChangeEvent>

Functions
getAccounts(providerId: string): Thenable<readonly
AuthenticationSessionAccountInformation[]>

getSession(providerId: string, scopeListOrRequest: readonly string[] |

AuthenticationWwwAuthenticateRequest, options: AuthenticationGetSessionOptions &
{createIfNone: true | AuthenticationGetSessionPresentationOptions}):
Thenable<AuthenticationSession>

getSession(providerId: string, scopeListOrRequest: readonly string[] |

AuthenticationWwwAuthenticateRequest, options: AuthenticationGetSessionOptions &
{forceNewSession: true | AuthenticationGetSessionPresentationOptions}):
Thenable<AuthenticationSession>

getSession(providerId: string, scopeListOrRequest: readonly string[] |

AuthenticationWwwAuthenticateRequest, options?: AuthenticationGetSessionOptions):
[Link] 1/230
1/21/26, 2:23 PM VS Code API | Visual Studio Code Extension API

Thenable<AuthenticationSession | undefined>

registerAuthenticationProvider(id: string, label: string, provider: AuthenticationProvider,

options?: AuthenticationProviderOptions): Disposable

chat
Namespace for chat functionality. Users interact with chat participants by sending messages to them in the
chat view. Chat participants can respond with markdown or other types of content via the
ChatResponseStream.
Functions
createChatParticipant(id: string, handler: ChatRequestHandler): ChatParticipant

commands
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 registerCommand and registerTextEditorCommand
functions. Commands can be executed manually or from a UI gesture. Those are:
palette - Use the commands -section in [Link] to make a command show in the command
palette ([Link]
keybinding - Use the keybindings -section in [Link] to enable keybindings
([Link] 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 [Link] .
JavaScript 

[Link]('[Link]', () => {
[Link]('Hello World!');
});

Second, bind the command identifier to a title under which it will show in the palette ( [Link] ).
JSON 

[Link] 2/230
1/21/26, 2:23 PM VS Code API | Visual Studio Code Extension API

{
"contributes": {
"commands": [
{
"command": "[Link]",
"title": "Hello World"
}
]
}
}

Functions
executeCommand<T>(command: string, ...rest: any[]): Thenable<T>

getCommands(filterInternal?: boolean): Thenable<string[]>

registerCommand(command: string, callback: (args: any[]) => any, thisArg?: any): Disposable

registerTextEditorCommand(command: string, callback: (textEditor: TextEditor, edit:

TextEditorEdit, args: any[]) => void, thisArg?: any): Disposable

comments
Functions
createCommentController(id: string, label: string): CommentController

debug
Namespace for debug functionality.
Variables
activeDebugConsole: DebugConsole

activeDebugSession: DebugSession | undefined

activeStackItem: DebugThread | DebugStackFrame | undefined

breakpoints: readonly Breakpoint[]

[Link] 3/230
1/21/26, 2:23 PM VS Code API | Visual Studio Code Extension API
Events
onDidChangeActiveDebugSession: Event<DebugSession | undefined>

onDidChangeActiveStackItem: Event<DebugThread | DebugStackFrame | undefined>

onDidChangeBreakpoints: Event<BreakpointsChangeEvent>

onDidReceiveDebugSessionCustomEvent: Event<DebugSessionCustomEvent>

onDidStartDebugSession: Event<DebugSession>

onDidTerminateDebugSession: Event<DebugSession>

Functions
addBreakpoints(breakpoints: readonly Breakpoint[]): void

asDebugSourceUri(source: DebugProtocolSource, session?: DebugSession): Uri

registerDebugAdapterDescriptorFactory(debugType: string, factory:

DebugAdapterDescriptorFactory): Disposable

registerDebugAdapterTrackerFactory(debugType: string, factory:

DebugAdapterTrackerFactory): Disposable

registerDebugConfigurationProvider(debugType: string, provider: DebugConfigurationProvider,

triggerKind?: DebugConfigurationProviderTriggerKind): Disposable

removeBreakpoints(breakpoints: readonly Breakpoint[]): void

startDebugging(folder: WorkspaceFolder, nameOrConfiguration: string | DebugConfiguration,

parentSessionOrOptions?: DebugSession | DebugSessionOptions): Thenable<boolean>

stopDebugging(session?: DebugSession): Thenable<void>

[Link] 4/230
 env
1/21/26, 2:23 PM VS Code API | Visual Studio Code Extension API

Namespace describing the environment the editor runs in.

Variables
appHost: string

appName: string

appRoot: string

clipboard: Clipboard

isNewAppInstall: boolean

isTelemetryEnabled: boolean

language: string

logLevel: LogLevel

machineId: string

remoteName: string | undefined

sessionId: string

shell: string

uiKind: UIKind

uriScheme: string

Events

[Link] 5/230
1/21/26, 2:23 PM VS Code API | Visual Studio Code Extension API

onDidChangeLogLevel: Event<LogLevel>

onDidChangeShell: Event<string>

onDidChangeTelemetryEnabled: Event<boolean>

Functions
asExternalUri(target: Uri): Thenable<Uri>

createTelemetryLogger(sender: TelemetrySender, options?: TelemetryLoggerOptions):

TelemetryLogger

openExternal(target: Uri): Thenable<boolean>

extensions
Namespace for dealing with installed extensions. Extensions are represented by an 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: [Link]) {

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

[Link] , and use the getExtension-function and the exports-property, like below:

JavaScript 

[Link] 6/230
1/21/26, 2:23 PM VS Code API | Visual Studio Code Extension API

let mathExt = [Link]('[Link]');

let importedApi = [Link];

[Link]([Link](42, 1));

Variables
all: readonly Extension<any>[]

Events
onDidChange: Event<void>

Functions
getExtension<T>(extensionId: string): Extension<T> | undefined

l10n
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..json files. For more information on how to
generate bundle.l10n..json files, check out the vscode-l10n repo ([Link]
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.
Variables
bundle: | undefined

uri: Uri | undefined

Functions
t(message: string, ...args: Array<string | number | boolean>): string

t(message: string, args: Record<string, string | number | boolean>): string

t(options: {args: Array<string | number | boolean> | Record<string, string | number | boolean>,

comment: string | string[], message: string}): string
[Link] 7/230
1/21/26, 2:23 PM VS Code API | Visual Studio Code Extension API

languages
Namespace for participating in language-specific editor features
([Link] 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 TextDocument and a
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 

[Link]('javascript', {
provideHover(document, position, token) {
return new Hover('I am a hover!');
}
});

Registration is done using a document selector which is either a language id, like javascript or a more
complex filter like { language: 'typescript', scheme: 'file' } . Matching a document against such a
selector will result in a 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 hover, the score is only checked
to be >0 , for other features, like IntelliSense the score is used for determining the order in which providers
are asked to participate.
Events
onDidChangeDiagnostics: Event<DiagnosticChangeEvent>

Functions
createDiagnosticCollection(name?: string): DiagnosticCollection

createLanguageStatusItem(id: string, selector: DocumentSelector): LanguageStatusItem

getDiagnostics(resource: Uri): Diagnostic[]

[Link] 8/230
1/21/26, 2:23 PM VS Code API | Visual Studio Code Extension API

getDiagnostics(): Array<[Uri, Diagnostic[]]>

getLanguages(): Thenable<string[]>

match(selector: DocumentSelector, document: TextDocument): number

registerCallHierarchyProvider(selector: DocumentSelector, provider: CallHierarchyProvider):

Disposable

registerCodeActionsProvider(selector: DocumentSelector, provider:

CodeActionProvider<CodeAction>, metadata?: CodeActionProviderMetadata): Disposable

registerCodeLensProvider(selector: DocumentSelector, provider:

CodeLensProvider<CodeLens>): Disposable

registerColorProvider(selector: DocumentSelector, provider: DocumentColorProvider):

Disposable

registerCompletionItemProvider(selector: DocumentSelector, provider:

CompletionItemProvider<CompletionItem>, ...triggerCharacters: string[]): Disposable

registerDeclarationProvider(selector: DocumentSelector, provider: DeclarationProvider):

Disposable

registerDefinitionProvider(selector: DocumentSelector, provider: DefinitionProvider): Disposable

registerDocumentDropEditProvider(selector: DocumentSelector, provider:

DocumentDropEditProvider<DocumentDropEdit>, metadata?:
DocumentDropEditProviderMetadata): Disposable

registerDocumentFormattingEditProvider(selector: DocumentSelector, provider:

DocumentFormattingEditProvider): Disposable

[Link] 9/230
1/21/26, 2:23 PM VS Code API | Visual Studio Code Extension API

registerDocumentHighlightProvider(selector: DocumentSelector, provider:

DocumentHighlightProvider): Disposable

registerDocumentLinkProvider(selector: DocumentSelector, provider:

DocumentLinkProvider<DocumentLink>): Disposable

registerDocumentPasteEditProvider(selector: DocumentSelector, provider:

DocumentPasteEditProvider<DocumentPasteEdit>, metadata:
DocumentPasteProviderMetadata): Disposable

registerDocumentRangeFormattingEditProvider(selector: DocumentSelector, provider:

DocumentRangeFormattingEditProvider): Disposable

registerDocumentRangeSemanticTokensProvider(selector: DocumentSelector, provider:

DocumentRangeSemanticTokensProvider, legend: SemanticTokensLegend): Disposable

registerDocumentSemanticTokensProvider(selector: DocumentSelector, provider:

DocumentSemanticTokensProvider, legend: SemanticTokensLegend): Disposable

registerDocumentSymbolProvider(selector: DocumentSelector, provider:

DocumentSymbolProvider, metaData?: DocumentSymbolProviderMetadata): Disposable

registerEvaluatableExpressionProvider(selector: DocumentSelector, provider:

EvaluatableExpressionProvider): Disposable

registerFoldingRangeProvider(selector: DocumentSelector, provider: FoldingRangeProvider):

Disposable

registerHoverProvider(selector: DocumentSelector, provider: HoverProvider): Disposable

registerImplementationProvider(selector: DocumentSelector, provider: ImplementationProvider):

Disposable

registerInlayHintsProvider(selector: DocumentSelector, provider:

InlayHintsProvider<InlayHint>): Disposable

[Link] 10/230
1/21/26, 2:23 PM VS Code API | Visual Studio Code Extension API

registerInlineCompletionItemProvider(selector: DocumentSelector, provider:

InlineCompletionItemProvider): Disposable

registerInlineValuesProvider(selector: DocumentSelector, provider: InlineValuesProvider):

Disposable

registerLinkedEditingRangeProvider(selector: DocumentSelector, provider:

LinkedEditingRangeProvider): Disposable

registerOnTypeFormattingEditProvider(selector: DocumentSelector, provider:

OnTypeFormattingEditProvider, firstTriggerCharacter: string, ...moreTriggerCharacter: string[]):
Disposable

registerReferenceProvider(selector: DocumentSelector, provider: ReferenceProvider):

Disposable

registerRenameProvider(selector: DocumentSelector, provider: RenameProvider): Disposable

registerSelectionRangeProvider(selector: DocumentSelector, provider: SelectionRangeProvider):

Disposable

registerSignatureHelpProvider(selector: DocumentSelector, provider: SignatureHelpProvider,

...triggerCharacters: string[]): Disposable

registerSignatureHelpProvider(selector: DocumentSelector, provider: SignatureHelpProvider,

metadata: SignatureHelpProviderMetadata): Disposable

registerTypeDefinitionProvider(selector: DocumentSelector, provider: TypeDefinitionProvider):

Disposable

registerTypeHierarchyProvider(selector: DocumentSelector, provider: TypeHierarchyProvider):

Disposable

registerWorkspaceSymbolProvider(provider: WorkspaceSymbolProvider<SymbolInformation>):
Disposable

[Link] 11/230
1/21/26, 2:23 PM VS Code API | Visual Studio Code Extension API

setLanguageConfiguration(language: string, configuration: LanguageConfiguration): Disposable

setTextDocumentLanguage(document: TextDocument, languageId: string):

Thenable<TextDocument>

lm
Namespace for language model related functionality.
Variables
tools: readonly LanguageModelToolInformation[]

Events
onDidChangeChatModels: Event<void>

Functions
invokeTool(name: string, options: LanguageModelToolInvocationOptions<object>, token?:
CancellationToken): Thenable<LanguageModelToolResult>

registerLanguageModelChatProvider(vendor: string, provider:

LanguageModelChatProvider<LanguageModelChatInformation>): Disposable

registerMcpServerDefinitionProvider(id: string, provider:

McpServerDefinitionProvider<McpServerDefinition>): Disposable

registerTool<T>(name: string, tool: LanguageModelTool<T>): Disposable

selectChatModels(selector?: LanguageModelChatSelector): Thenable<LanguageModelChat[]>

notebooks
Namespace for notebooks.
The notebooks functionality is composed of three loosely coupled components:
1 NotebookSerializer enable the editor to open, show, and save notebooks
2 NotebookController own the execution of notebooks, e.g they create output from code cells.
[Link] 12/230
1/21/26, 2:23 PM VS Code API | Visual Studio Code Extension API

3 NotebookRenderer present notebook output in the editor. They run in a separate context.
Functions
createNotebookController(id: string, notebookType: string, label: string, handler?: (cells:
NotebookCell[], notebook: NotebookDocument, controller: NotebookController) => void |
Thenable<void>): NotebookController

createRendererMessaging(rendererId: string): NotebookRendererMessaging

registerNotebookCellStatusBarItemProvider(notebookType: string, provider:

NotebookCellStatusBarItemProvider): Disposable

scm
Namespace for source control management.
Variables
inputBox: SourceControlInputBox

Functions
createSourceControl(id: string, label: string, rootUri?: Uri): SourceControl

tasks
Namespace for tasks functionality.
Variables
taskExecutions: readonly TaskExecution[]

Events
onDidEndTask: Event<TaskEndEvent>

onDidEndTaskProcess: Event<TaskProcessEndEvent>

onDidStartTask: Event<TaskStartEvent>

[Link] 13/230
1/21/26, 2:23 PM VS Code API | Visual Studio Code Extension API

onDidStartTaskProcess: Event<TaskProcessStartEvent>

Functions
executeTask(task: Task): Thenable<TaskExecution>

fetchTasks(filter?: TaskFilter): Thenable<Task[]>

registerTaskProvider(type: string, provider: TaskProvider<Task>): Disposable

tests
Namespace for testing functionality. Tests are published by registering TestController instances, then
adding TestItems. Controllers may also describe how to run tests by creating one or more TestRunProfile
instances.
Functions
createTestController(id: string, label: string): TestController

window
Namespace for dealing with the current window of the editor. That is visible and active editors, as well as,
UI elements to show messages, selections, and asking for user input.
Variables
activeColorTheme: ColorTheme

activeNotebookEditor: NotebookEditor | undefined

activeTerminal: Terminal | undefined

activeTextEditor: TextEditor | undefined

state: WindowState

tabGroups: TabGroups
[Link] 14/230
1/21/26, 2:23 PM VS Code API | Visual Studio Code Extension API

terminals: readonly Terminal[]

visibleNotebookEditors: readonly NotebookEditor[]

visibleTextEditors: readonly TextEditor[]

Events
onDidChangeActiveColorTheme: Event<ColorTheme>

onDidChangeActiveNotebookEditor: Event<NotebookEditor | undefined>

onDidChangeActiveTerminal: Event<Terminal | undefined>

onDidChangeActiveTextEditor: Event<TextEditor | undefined>

onDidChangeNotebookEditorSelection: Event<NotebookEditorSelectionChangeEvent>

onDidChangeNotebookEditorVisibleRanges: Event<NotebookEditorVisibleRangesChangeEvent>

onDidChangeTerminalShellIntegration: Event<TerminalShellIntegrationChangeEvent>

onDidChangeTerminalState: Event<Terminal>

onDidChangeTextEditorOptions: Event<TextEditorOptionsChangeEvent>

onDidChangeTextEditorSelection: Event<TextEditorSelectionChangeEvent>

onDidChangeTextEditorViewColumn: Event<TextEditorViewColumnChangeEvent>

onDidChangeTextEditorVisibleRanges: Event<TextEditorVisibleRangesChangeEvent>

onDidChangeVisibleNotebookEditors: Event<readonly NotebookEditor[]>

[Link] 15/230
1/21/26, 2:23 PM VS Code API | Visual Studio Code Extension API

onDidChangeVisibleTextEditors: Event<readonly TextEditor[]>

onDidChangeWindowState: Event<WindowState>

onDidCloseTerminal: Event<Terminal>

onDidEndTerminalShellExecution: Event<TerminalShellExecutionEndEvent>

onDidOpenTerminal: Event<Terminal>

onDidStartTerminalShellExecution: Event<TerminalShellExecutionStartEvent>

Functions
createInputBox(): InputBox

createOutputChannel(name: string, languageId?: string): OutputChannel

createOutputChannel(name: string, options: {log: true}): LogOutputChannel

createQuickPick<T extends QuickPickItem>(): QuickPick<T>

createStatusBarItem(id: string, alignment?: StatusBarAlignment, priority?: number):

StatusBarItem

createStatusBarItem(alignment?: StatusBarAlignment, priority?: number): StatusBarItem

createTerminal(name?: string, shellPath?: string, shellArgs?: string | readonly string[]): Terminal

createTerminal(options: TerminalOptions): Terminal

createTerminal(options: ExtensionTerminalOptions): Terminal

createTextEditorDecorationType(options: DecorationRenderOptions): TextEditorDecorationType

[Link] 16/230
1/21/26, 2:23 PM VS Code API | Visual Studio Code Extension API

createTreeView<T>(viewId: string, options: TreeViewOptions<T>): TreeView<T>

createWebviewPanel(viewType: string, title: string, showOptions: ViewColumn | {preserveFocus:

boolean, viewColumn: ViewColumn}, options?: WebviewPanelOptions & WebviewOptions):
WebviewPanel

registerCustomEditorProvider(viewType: string, provider: CustomTextEditorProvider |

CustomReadonlyEditorProvider<CustomDocument> |
CustomEditorProvider<CustomDocument>, options?: {supportsMultipleEditorsPerDocument:
boolean, webviewOptions: WebviewPanelOptions}): Disposable

registerFileDecorationProvider(provider: FileDecorationProvider): Disposable

registerTerminalLinkProvider(provider: TerminalLinkProvider<TerminalLink>): Disposable

registerTerminalProfileProvider(id: string, provider: TerminalProfileProvider): Disposable

registerTreeDataProvider<T>(viewId: string, treeDataProvider: TreeDataProvider<T>):

Disposable

registerUriHandler(handler: UriHandler): Disposable

registerWebviewPanelSerializer(viewType: string, serializer:

WebviewPanelSerializer<unknown>): Disposable

registerWebviewViewProvider(viewId: string, provider: WebviewViewProvider, options?:

{webviewOptions: {retainContextWhenHidden: boolean}}): Disposable

setStatusBarMessage(text: string, hideAfterTimeout: number): Disposable

setStatusBarMessage(text: string, hideWhenDone: Thenable<any>): Disposable

setStatusBarMessage(text: string): Disposable

[Link] 17/230
1/21/26, 2:23 PM VS Code API | Visual Studio Code Extension API

showErrorMessage<T extends string>(message: string, ...items: T[]): Thenable<T | undefined>

showErrorMessage<T extends string>(message: string, options: MessageOptions, ...items: T[]):

Thenable<T | undefined>

showErrorMessage<T extends MessageItem>(message: string, ...items: T[]): Thenable<T |

undefined>

showErrorMessage<T extends MessageItem>(message: string, options: MessageOptions,

...items: T[]): Thenable<T | undefined>

showInformationMessage<T extends string>(message: string, ...items: T[]): Thenable<T |

undefined>

showInformationMessage<T extends string>(message: string, options: MessageOptions,

...items: T[]): Thenable<T | undefined>

showInformationMessage<T extends MessageItem>(message: string, ...items: T[]): Thenable<T

| undefined>

showInformationMessage<T extends MessageItem>(message: string, options: MessageOptions,

...items: T[]): Thenable<T | undefined>

showInputBox(options?: InputBoxOptions, token?: CancellationToken): Thenable<string |

undefined>

showNotebookDocument(document: NotebookDocument, options?:

NotebookDocumentShowOptions): Thenable<NotebookEditor>

showOpenDialog(options?: OpenDialogOptions): Thenable<Uri[] | undefined>

showQuickPick(items: readonly string[] | Thenable<readonly string[]>, options:

QuickPickOptions & {canPickMany: true}, token?: CancellationToken): Thenable<string[] |
undefined>

[Link] 18/230
1/21/26, 2:23 PM VS Code API | Visual Studio Code Extension API

showQuickPick(items: readonly string[] | Thenable<readonly string[]>, options?:

QuickPickOptions, token?: CancellationToken): Thenable<string | undefined>

showQuickPick<T extends QuickPickItem>(items: readonly T[] | Thenable<readonly T[]>,

options: QuickPickOptions & {canPickMany: true}, token?: CancellationToken): Thenable<T[] |
undefined>

showQuickPick<T extends QuickPickItem>(items: readonly T[] | Thenable<readonly T[]>,

options?: QuickPickOptions, token?: CancellationToken): Thenable<T | undefined>

showSaveDialog(options?: SaveDialogOptions): Thenable<Uri | undefined>

showTextDocument(document: TextDocument, column?: ViewColumn, preserveFocus?:

boolean): Thenable<TextEditor>

showTextDocument(document: TextDocument, options?: TextDocumentShowOptions):

Thenable<TextEditor>

showTextDocument(uri: Uri, options?: TextDocumentShowOptions): Thenable<TextEditor>

showWarningMessage<T extends string>(message: string, ...items: T[]): Thenable<T |

undefined>

showWarningMessage<T extends string>(message: string, options: MessageOptions, ...items:

T[]): Thenable<T | undefined>

showWarningMessage<T extends MessageItem>(message: string, ...items: T[]): Thenable<T |

undefined>

showWarningMessage<T extends MessageItem>(message: string, options: MessageOptions,

...items: T[]): Thenable<T | undefined>

showWorkspaceFolderPick(options?: WorkspaceFolderPickOptions):
Thenable<WorkspaceFolder | undefined>

[Link] 19/230
1/21/26, 2:23 PM VS Code API | Visual Studio Code Extension API

withProgress<R>(options: ProgressOptions, task: (progress: Progress<{increment: number,

message: string}>, token: CancellationToken) => Thenable<R>): Thenable<R>

withScmProgress<R>(task: (progress: Progress<number>) => Thenable<R>): Thenable<R>

workspace
Namespace for dealing with the current workspace. A workspace is the collection of one or more folders
that are opened in an editor window (instance).
It is also possible to open an editor without a workspace. For example, when you open a new editor window
by selecting a file from your platform's File menu, you will not be inside a workspace. In this mode, some of
the editor's capabilities are reduced but you can still open text files and edit them.
Refer to [Link]
([Link] for more information on the concept of
workspaces.
The workspace offers support for listening to fs events and for finding files. Both perform well and run
outside the editor-process so that they should be always used instead of nodejs-equivalents.
Variables
fs: FileSystem

isTrusted: boolean

name: string | undefined

notebookDocuments: readonly NotebookDocument[]

rootPath: string | undefined

textDocuments: readonly TextDocument[]

workspaceFile: Uri | undefined

workspaceFolders: readonly WorkspaceFolder[] | undefined

Events
[Link] 20/230