@codingame/monaco-vscode-extensions-service-override 1.82.5-next.0 → 1.82.5

package/vscode-proposed.d.ts

@@ -0,0 +1,3704 @@
+import * as vscode from 'vscode';
+import { CancellationToken, ProviderResult, Disposable, Uri, Progress, MarkdownString, ThemeIcon, ThemeColor, TextDocument, WebviewPanel, DebugSession, Event, Range, DataTransfer, SnippetString, WorkspaceEdit, WorkspaceFolder, TextEditor, Webview, CommentThreadCollapsibleState, CommentThreadState, CommentThread, GlobPattern, Command, Selection, TextEdit, CompletionItemKind, DocumentSelector, CodeActionKind, NotebookDocument, NotebookControllerAffinity, NotebookEditor, QuickInput, TabInputText, TabInputTextDiff, TabInputCustom, TabInputWebview, TabInputNotebook, TabInputNotebookDiff, TabInputTerminal, TerminalDimensions, WebviewOptions, Position, TestMessage, TestRunRequest, TestItem, AccessibilityInformation, DocumentDropEditProvider, TreeViewExpansionEvent, TreeViewSelectionChangeEvent, TreeViewVisibilityChangeEvent, TreeCheckboxChangeEvent, ViewBadge, NotebookSerializer } from 'vscode';
+export * from 'vscode';
+
+// https://github.com/microsoft/vscode/issues/190909
+
+	declare enum RelatedInformationType {
+		SymbolInformation = 1,
+		CommandInformation = 2,
+		SearchInformation = 3,
+		SettingInformation = 4
+	}
+
+	interface RelatedInformationBaseResult {
+		type: RelatedInformationType;
+		weight: number;
+	}
+
+	// TODO: Symbols and Search
+
+	interface CommandInformationResult extends RelatedInformationBaseResult {
+		type: RelatedInformationType.CommandInformation;
+		command: string;
+	}
+
+	interface SettingInformationResult extends RelatedInformationBaseResult {
+		type: RelatedInformationType.SettingInformation;
+		setting: string;
+	}
+
+	type RelatedInformationResult = CommandInformationResult | SettingInformationResult;
+
+	interface RelatedInformationProvider {
+		provideRelatedInformation(query: string, token: CancellationToken): ProviderResult<RelatedInformationResult[]>;
+	}
+
+	interface EmbeddingVectorProvider {
+		provideEmbeddingVector(strings: string[], token: CancellationToken): ProviderResult<number[][]>;
+	}
+
+	declare namespace ai {
+		export function getRelatedInformation(query: string, types: RelatedInformationType[], token: CancellationToken): Thenable<RelatedInformationResult[]>;
+		export function registerRelatedInformationProvider(type: RelatedInformationType, provider: RelatedInformationProvider): Disposable;
+		export function registerEmbeddingVectorProvider(model: string, provider: EmbeddingVectorProvider): Disposable;
+	}
+// https://github.com/microsoft/vscode/issues/152399
+
+	interface AuthenticationForceNewSessionOptions {
+		/**
+		 * The session that you are asking to be recreated. The Auth Provider can use this to
+		 * help guide the user to log in to the correct account.
+		 */
+		sessionToRecreate?: AuthenticationSession;
+	}
+
+	/**
+	 * The options passed in to the provider when creating a session.
+	 */
+	interface AuthenticationProviderCreateSessionOptions {
+		/**
+		 * The session that is being asked to be recreated. If this is passed in, the provider should
+		 * attempt to recreate the session based on the information in this session.
+		 */
+		sessionToRecreate?: AuthenticationSession;
+	}
+
+	interface AuthenticationProvider {
+		/**
+		 * 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.
+		 * @param scopes A list of scopes, permissions, that the new session should be created with.
+		 * @param options Additional options for creating a session.
+		 * @returns A promise that resolves to an authentication session.
+		 */
+		createSession(scopes: readonly string[], options: AuthenticationProviderCreateSessionOptions): Thenable<AuthenticationSession>;
+	}
+
+	declare namespace authentication {
+		/**
+		 * Get all authentication sessions matching the desired scopes that this extension has access to. In order to request access,
+		 * use {@link getSession}. To request an additional account, specify {@link AuthenticationGetSessionOptions.clearSessionPreference}
+		 * and {@link AuthenticationGetSessionOptions.createIfNone} together.
+		 *
+		 * Currently, there are only two authentication providers that are contributed from built in extensions
+		 * to the editor that implement GitHub and Microsoft authentication: their providerId's are 'github' and 'microsoft'.
+		 *
+		 * @param providerId The id of the provider to use
+		 * @param scopes A list of scopes representing the permissions requested. These are dependent on the authentication provider
+		 * @returns A thenable that resolves to a readonly array of authentication sessions.
+		 */
+		export function getSessions(providerId: string, scopes: readonly string[]): Thenable<readonly AuthenticationSession[]>;
+	}
+declare namespace authentication {
+	/**
+	 * @deprecated Use {@link getSession()} {@link AuthenticationGetSessionOptions.silent} instead.
+	 */
+	export function hasSession(providerId: string, scopes: readonly string[]): Thenable<boolean>;
+}
+
+	interface CanonicalUriProvider {
+		/**
+		 *
+		 * @param uri The URI to provide a canonical URI for.
+		 * @param options Options that the provider should honor in the URI it returns.
+		 * @param token A cancellation token for the request.
+		 * @returns The canonical URI for the requested URI or undefined if no canonical URI can be provided.
+		 */
+		provideCanonicalUri(uri: Uri, options: CanonicalUriRequestOptions, token: CancellationToken): ProviderResult<Uri>;
+	}
+
+	interface CanonicalUriRequestOptions {
+		/**
+		 *
+		 * The desired scheme of the canonical URI.
+		 */
+		targetScheme: string;
+	}
+// ChatML
+	declare enum ChatMessageRole {
+		System = 0,
+		User = 1,
+		Assistant = 2,
+		Function = 3,
+	}
+
+	// ChatML
+	declare class ChatMessage {
+		role: ChatMessageRole;
+		content: string;
+		name?: string;
+
+		constructor(role: ChatMessageRole, content: string);
+	}
+
+	/**
+	 * Represents a large language model that accepts ChatML messages and produces a streaming response
+	 */
+	interface ChatResponseProvider {
+		provideChatResponse(messages: ChatMessage[], options: { [name: string]: any }, progress: Progress<ChatResponseFragment>, token: CancellationToken): Thenable<any>;
+	}
+
+	interface ChatResponseProviderMetadata {
+		// TODO: add way to compute token count
+		name: string;
+	}
+interface ChatResponseFragment {
+		index: number;
+		part: string;
+	}
+interface ChatResponseFragment {
+		index: number;
+		part: string;
+	}
+
+	/**
+	 * Represents access to using a chat provider (LLM). Access is granted and temporary, usually only valid
+	 * for the duration of an user interaction.
+	 */
+	interface ChatAccess {
+
+		/**
+		 * Whether the access to chat has been revoked. This happens when the user interaction that allowed for
+		 * chat access is finished.
+		 */
+		isRevoked: boolean;
+
+		/**
+		 * TODO: return an AsyncIterable instead of asking to pass Progress<...>?
+		 *
+		 * @param messages
+		 * @param options
+		 * @param progress
+		 * @param token
+		 */
+		makeRequest(messages: ChatMessage[], options: { [name: string]: any }, progress: Progress<ChatResponseFragment>, token: CancellationToken): Thenable<any>;
+	}
+interface SlashCommandContext {
+
+		// messages so far
+		history: ChatMessage[];
+
+		// TODO: access to embeddings
+		// embeddings: {};
+
+		// TODO: access to "InputSourceId"
+		// DebugConsoleOutput
+		// Terminal
+		// CorrespondingTestFile
+		// CorrespondingImplementationFile
+		// ExtensionApi
+		// VSCode
+		// Workspace
+	}
+
+	interface SlashResponse {
+		message: MarkdownString;
+		// edits?: TextEdit[] | WorkspaceEdit;
+	}
+
+	interface SlashResult {
+		// followUp?: InteractiveSessionFollowup[];
+	}
+
+	interface SlashCommandMetadata {
+		description: string;
+	}
+
+	interface SlashCommand {
+
+		(prompt: ChatMessage, context: SlashCommandContext, progress: Progress<SlashResponse>, token: CancellationToken): Thenable<SlashResult>;
+	}
+
+	declare enum ChatVariableLevel {
+		Short = 1,
+		Medium = 2,
+		Full = 3
+	}
+
+	interface ChatVariableValue {
+		level: ChatVariableLevel;
+		value: string;
+		description?: string;
+	}
+
+	interface ChatVariableContext {
+		message: string;
+	}
+
+	interface ChatVariableResolver {
+		resolve(name: string, context: ChatVariableContext, token: CancellationToken): ProviderResult<ChatVariableValue[]>;
+	}
+// https://github.com/microsoft/vscode/issues/135591 @alexr00
+
+	// export interface FileDecorationProvider {
+	// 	provideFileDecoration(uri: Uri, token: CancellationToken): ProviderResult<FileDecoration | FileDecoration1>;
+	// }
+
+	/**
+	 * A file decoration represents metadata that can be rendered with a file.
+	 */
+	declare class FileDecoration2 {
+		/**
+		 * A very short string that represents this decoration.
+		 */
+		badge?: string | ThemeIcon;
+
+		/**
+		 * A human-readable tooltip for this decoration.
+		 */
+		tooltip?: string;
+
+		/**
+		 * The color of this decoration.
+		 */
+		color?: ThemeColor;
+
+		/**
+		 * A flag expressing that this decoration should be
+		 * propagated to its parents.
+		 */
+		propagate?: boolean;
+
+		/**
+		 * Creates a new decoration.
+		 *
+		 * @param badge A letter that represents the decoration.
+		 * @param tooltip The tooltip of the decoration.
+		 * @param color The color of the decoration.
+		 */
+		constructor(badge?: string | ThemeIcon, tooltip?: string, color?: ThemeColor);
+	}
+// https://github.com/microsoft/vscode/issues/171166
+
+	declare enum CommentState {
+		Published = 0,
+		Draft = 1
+	}
+
+	interface Comment {
+		state?: CommentState;
+	}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// https://github.com/microsoft/vscode/issues/86146
+
+	// TODO: Also for custom editor
+
+	interface CustomTextEditorProvider {
+
+		/**
+		 * Handle when the underlying resource for a custom editor is renamed.
+		 *
+		 * This allows the webview for the editor be preserved throughout the rename. If this method is not implemented,
+		 * the editor will destroy the previous custom editor and create a replacement one.
+		 *
+		 * @param newDocument New text document to use for the custom editor.
+		 * @param existingWebviewPanel Webview panel for the custom editor.
+		 * @param token A cancellation token that indicates the result is no longer needed.
+		 *
+		 * @return Thenable indicating that the webview editor has been moved.
+		 */
+		// eslint-disable-next-line local/vscode-dts-provider-naming
+		moveCustomTextEditor?(newDocument: TextDocument, existingWebviewPanel: WebviewPanel, token: CancellationToken): Thenable<void>;
+	}
+// See https://github.com/microsoft/vscode/issues/63943
+
+	declare class ThreadFocus {
+		/**
+		 * Create a ThreadFocus
+		 * @param session
+		 * @param threadId
+		 * @param frameId
+		 */
+		constructor(
+			session: DebugSession,
+			threadId?: number);
+
+
+		/**
+		 * Debug session for thread.
+		 */
+		readonly session: DebugSession;
+
+		/**
+		 * Id of the associated thread (DAP id). May be undefined if thread has become unselected.
+		 */
+		readonly threadId: number | undefined;
+	}
+
+	declare class StackFrameFocus {
+		/**
+		 * Create a StackFrameFocus
+		 * @param session
+		 * @param threadId
+		 * @param frameId
+		 */
+		constructor(
+			session: DebugSession,
+			threadId?: number,
+			frameId?: number);
+
+
+		/**
+		 * Debug session for thread.
+		 */
+		readonly session: DebugSession;
+
+		/**
+		 * Id of the associated thread (DAP id). May be undefined if a frame is unselected.
+		 */
+		readonly threadId: number | undefined;
+		/**
+		 * Id of the stack frame (DAP id). May be undefined if a frame is unselected.
+		 */
+		readonly frameId: number | undefined;
+	}
+
+
+	declare namespace debug {
+		/**
+		 * The currently focused thread or stack frame id, or `undefined` if this has not been set. (e.g. not in debug mode).
+		 */
+		export let stackFrameFocus: ThreadFocus | StackFrameFocus | undefined;
+
+		/**
+		 * An {@link Event} which fires when the {@link debug.stackFrameFocus} changes. Provides a sessionId. threadId is not undefined
+		 * when a thread of frame has gained focus. frameId is defined when a stackFrame has gained focus.
+		 */
+		export const onDidChangeStackFrameFocus: Event<ThreadFocus | StackFrameFocus | undefined>;
+	}
+// https://github.com/microsoft/vscode/issues/84899
+
+	/**
+	 * The contiguous set of modified lines in a diff.
+	 */
+	interface LineChange {
+		readonly originalStartLineNumber: number;
+		readonly originalEndLineNumber: number;
+		readonly modifiedStartLineNumber: number;
+		readonly modifiedEndLineNumber: number;
+	}
+
+	declare namespace commands {
+
+		/**
+		 * Registers a diff information command that can be invoked via a keyboard shortcut,
+		 * a menu item, an action, or directly.
+		 *
+		 * Diff information commands are different from ordinary {@link commands.registerCommand commands} as
+		 * they only execute when there is an active diff editor when the command is called, and the diff
+		 * information has been computed. Also, the command handler of an editor command has access to
+		 * the diff information.
+		 *
+		 * @param command A unique identifier for the command.
+		 * @param callback A command handler function with access to the {@link LineChange diff information}.
+		 * @param thisArg The `this` context used when invoking the handler function.
+		 * @return Disposable which unregisters this command on disposal.
+		 */
+		export function registerDiffInformationCommand(command: string, callback: (diff: LineChange[], ...args: any[]) => any, thisArg?: any): Disposable;
+	}
+// TODO@rebornix: add github issue link
+
+	interface NotebookDocumentContentOptions {
+		/**
+		 * Controls if a cell metadata property should be reverted when the cell content
+		 * is reverted in notebook diff editor.
+		 */
+		cellContentMetadata?: { [key: string]: boolean | undefined };
+	}
+// todo@jrieken add issue reference
+
+	interface DocumentFilter {
+		readonly exclusive?: boolean;
+	}
+// https://github.com/microsoft/vscode/issues/30066/
+
+	/**
+	 * Provider invoked when the user copies and pastes code.
+	 */
+	interface DocumentPasteEditProvider {
+
+		/**
+		 * Optional method invoked after the user copies text in a file.
+		 *
+		 * During {@link prepareDocumentPaste}, an extension can compute metadata that is attached to
+		 * a {@link DataTransfer} and is passed back to the provider in {@link provideDocumentPasteEdits}.
+		 *
+		 * @param document Document where the copy took place.
+		 * @param ranges Ranges being copied in the `document`.
+		 * @param dataTransfer The data transfer associated with the copy. You can store additional values on this for later use in  {@link provideDocumentPasteEdits}.
+		 * @param token A cancellation token.
+		 */
+		prepareDocumentPaste?(document: TextDocument, ranges: readonly Range[], dataTransfer: DataTransfer, token: CancellationToken): void | Thenable<void>;
+
+		/**
+		 * Invoked before the user pastes into a document.
+		 *
+		 * In this method, extensions can return a workspace edit that replaces the standard pasting behavior.
+		 *
+		 * @param document Document being pasted into
+		 * @param ranges Currently selected ranges in the document.
+		 * @param dataTransfer The data transfer associated with the paste.
+		 * @param token A cancellation token.
+		 *
+		 * @return Optional workspace edit that applies the paste. Return undefined to use standard pasting.
+		 */
+		provideDocumentPasteEdits?(document: TextDocument, ranges: readonly Range[], dataTransfer: DataTransfer, token: CancellationToken): ProviderResult<DocumentPasteEdit>;
+	}
+
+	/**
+	 * An operation applied on paste
+	 */
+	declare class DocumentPasteEdit {
+
+		/**
+		 * Human readable label that describes the edit.
+		 */
+		label: string;
+
+		/**
+		 * Controls the ordering or multiple paste edits. If this provider yield to edits, it will be shown lower in the list.
+		 */
+		yieldTo?: ReadonlyArray<
+			| { readonly extensionId: string; readonly providerId: string }
+			| { readonly mimeType: string }
+		>;
+
+		/**
+		 * The text or snippet to insert at the pasted locations.
+		 */
+		insertText: string | SnippetString;
+
+		/**
+		 * An optional additional edit to apply on paste.
+		 */
+		additionalEdit?: WorkspaceEdit;
+
+		/**
+		 * @param insertText The text or snippet to insert at the pasted locations.
+		 *
+		 * TODO: Reverse args, but this will break existing consumers :(
+		 */
+		constructor(insertText: string | SnippetString, label: string);
+	}
+
+	interface DocumentPasteProviderMetadata {
+		/**
+		 * Identifies the provider.
+		 *
+		 * This id is used when users configure the default provider for paste.
+		 *
+		 * This id should be unique within the extension but does not need to be unique across extensions.
+		 */
+		readonly id: string;
+
+		/**
+		 * Mime types that {@link DocumentPasteEditProvider.prepareDocumentPaste provideDocumentPasteEdits} may add on copy.
+		 */
+		readonly copyMimeTypes?: readonly string[];
+
+		/**
+		 * Mime types that {@link DocumentPasteEditProvider.provideDocumentPasteEdits provideDocumentPasteEdits} should be invoked for.
+		 *
+		 * This can either be an exact mime type such as `image/png`, or a wildcard pattern such as `image/*`.
+		 *
+		 * Use `text/uri-list` for resources dropped from the explorer or other tree views in the workbench.
+		 *
+		 * Use `files` to indicate that the provider should be invoked if any {@link DataTransferFile files} are present in the {@link DataTransfer}.
+		 * Note that {@link DataTransferFile} entries are only created when dropping content from outside the editor, such as
+		 * from the operating system.
+		 */
+		readonly pasteMimeTypes?: readonly string[];
+	}
+// https://github.com/microsoft/vscode/issues/179430
+
+	interface DocumentDropEdit {
+		/**
+		 * Human readable label that describes the edit.
+		 */
+		label?: string;
+
+		/**
+		 * The mime type from the {@link DataTransfer} that this edit applies.
+		 *
+		 * TODO: Should this be taken from `dropMimeTypes` instead?
+		 */
+		handledMimeType?: string;
+
+		/**
+		 * Controls the ordering or multiple paste edits. If this provider yield to edits, it will be shown lower in the list.
+		 */
+		yieldTo?: ReadonlyArray<
+			// TODO: what about built-in providers?
+			| { readonly extensionId: string; readonly providerId: string }
+			| { readonly mimeType: string }
+		>;
+	}
+
+	interface DocumentDropEditProviderMetadata {
+		/**
+		 * Identifies the provider.
+		 *
+		 * This id is used when users configure the default provider for drop.
+		 *
+		 * This id should be unique within the extension but does not need to be unique across extensions.
+		 */
+		readonly id: string;
+
+		/**
+		 * List of {@link DataTransfer} mime types that the provider can handle.
+		 *
+		 * This can either be an exact mime type such as `image/png`, or a wildcard pattern such as `image/*`.
+		 *
+		 * Use `text/uri-list` for resources dropped from the explorer or other tree views in the workbench.
+		 *
+		 * Use `files` to indicate that the provider should be invoked if any {@link DataTransferFile files} are present in the {@link DataTransfer}.
+		 * Note that {@link DataTransferFile} entries are only created when dropping content from outside the editor, such as
+		 * from the operating system.
+		 */
+		readonly dropMimeTypes: readonly string[];
+	}
+
+	interface EditSessionIdentityProvider {
+		/**
+		 *
+		 * @param workspaceFolder The workspace folder to provide an edit session identity for.
+		 * @param token A cancellation token for the request.
+		 * @returns A string representing the edit session identity for the requested workspace folder.
+		 */
+		provideEditSessionIdentity(workspaceFolder: WorkspaceFolder, token: CancellationToken): ProviderResult<string>;
+
+		/**
+		 *
+		 * @param identity1 An edit session identity.
+		 * @param identity2 A second edit session identity to compare to @param identity1.
+		 * @param token A cancellation token for the request.
+		 * @returns An {@link EditSessionIdentityMatch} representing the edit session identity match confidence for the provided identities.
+		 */
+		provideEditSessionIdentityMatch(identity1: string, identity2: string, token: CancellationToken): ProviderResult<EditSessionIdentityMatch>;
+	}
+
+	declare enum EditSessionIdentityMatch {
+		Complete = 100,
+		Partial = 50,
+		None = 0
+	}
+
+	interface EditSessionIdentityWillCreateEvent {
+
+		/**
+		 * A cancellation token.
+		 */
+		readonly token: CancellationToken;
+
+		/**
+		 * The workspace folder to create an edit session identity for.
+		 */
+		readonly workspaceFolder: WorkspaceFolder;
+
+		/**
+		 * Allows to pause the event until the provided thenable resolves.
+		 *
+		 * *Note:* This function can only be called during event dispatch.
+		 *
+		 * @param thenable A thenable that delays saving.
+		 */
+		waitUntil(thenable: Thenable<any>): void;
+	}
+interface WebviewEditorInset {
+		readonly editor: TextEditor;
+		readonly line: number;
+		readonly height: number;
+		readonly webview: Webview;
+		readonly onDidDispose: Event<void>;
+		dispose(): void;
+	}
+// https://github.com/microsoft/vscode/issues/104436
+
+	declare enum ExtensionRuntime {
+		/**
+		 * The extension is running in a NodeJS extension host. Runtime access to NodeJS APIs is available.
+		 */
+		Node = 1,
+		/**
+		 * The extension is running in a Webworker extension host. Runtime access is limited to Webworker APIs.
+		 */
+		Webworker = 2
+	}
+// https://github.com/microsoft/vscode/issues/145307
+
+	interface Extension<T> {
+
+		/**
+		 * `true` when the extension is associated to another extension host.
+		 *
+		 * *Note* that an extension from another extension host cannot export
+		 * API, e.g {@link Extension.exports its exports} are always `undefined`.
+		 */
+		readonly isFromDifferentExtensionHost: boolean;
+	}
+
+	declare namespace extensions {
+
+		/**
+		 * Get an extension by its full identifier in the form of: `publisher.name`.
+		 *
+		 * @param extensionId An extension identifier.
+		 * @param includeDifferentExtensionHosts Include extensions from different extension host
+		 * @return An extension or `undefined`.
+		 */
+		export function getExtension<T = any>(extensionId: string, includeDifferentExtensionHosts: boolean): Extension<T> | undefined;
+
+		/**
+		 * All extensions across all extension hosts.
+		 *
+		 * @see {@link Extension.isFromDifferentExtensionHost}
+		 */
+		export const allAcrossExtensionHosts: readonly Extension<void>[];
+
+	}
+// https://github.com/microsoft/vscode/issues/109277
+
+	/**
+	 * Details if an `ExternalUriOpener` can open a uri.
+	 *
+	 * The priority is also used to rank multiple openers against each other and determine
+	 * if an opener should be selected automatically or if the user should be prompted to
+	 * select an opener.
+	 *
+	 * The editor will try to use the best available opener, as sorted by `ExternalUriOpenerPriority`.
+	 * If there are multiple potential "best" openers for a URI, then the user will be prompted
+	 * to select an opener.
+	 */
+	declare enum ExternalUriOpenerPriority {
+		/**
+		 * The opener is disabled and will never be shown to users.
+		 *
+		 * Note that the opener can still be used if the user specifically
+		 * configures it in their settings.
+		 */
+		None = 0,
+
+		/**
+		 * The opener can open the uri but will not cause a prompt on its own
+		 * since the editor always contributes a built-in `Default` opener.
+		 */
+		Option = 1,
+
+		/**
+		 * The opener can open the uri.
+		 *
+		 * The editor's built-in opener has `Default` priority. This means that any additional `Default`
+		 * openers will cause the user to be prompted to select from a list of all potential openers.
+		 */
+		Default = 2,
+
+		/**
+		 * The opener can open the uri and should be automatically selected over any
+		 * default openers, include the built-in one from the editor.
+		 *
+		 * A preferred opener will be automatically selected if no other preferred openers
+		 * are available. If multiple preferred openers are available, then the user
+		 * is shown a prompt with all potential openers (not just preferred openers).
+		 */
+		Preferred = 3,
+	}
+
+	/**
+	 * Handles opening uris to external resources, such as http(s) links.
+	 *
+	 * Extensions can implement an `ExternalUriOpener` to open `http` links to a webserver
+	 * inside of the editor instead of having the link be opened by the web browser.
+	 *
+	 * Currently openers may only be registered for `http` and `https` uris.
+	 */
+	interface ExternalUriOpener {
+
+		/**
+		 * Check if the opener can open a uri.
+		 *
+		 * @param uri The uri being opened. This is the uri that the user clicked on. It has
+		 * not yet gone through port forwarding.
+		 * @param token Cancellation token indicating that the result is no longer needed.
+		 *
+		 * @return Priority indicating if the opener can open the external uri.
+		 */
+		canOpenExternalUri(uri: Uri, token: CancellationToken): ExternalUriOpenerPriority | Thenable<ExternalUriOpenerPriority>;
+
+		/**
+		 * Open a uri.
+		 *
+		 * This is invoked when:
+		 *
+		 * - The user clicks a link which does not have an assigned opener. In this case, first `canOpenExternalUri`
+		 *   is called and if the user selects this opener, then `openExternalUri` is called.
+		 * - The user sets the default opener for a link in their settings and then visits a link.
+		 *
+		 * @param resolvedUri The uri to open. This uri may have been transformed by port forwarding, so it
+		 * may not match the original uri passed to `canOpenExternalUri`. Use `ctx.originalUri` to check the
+		 * original uri.
+		 * @param ctx Additional information about the uri being opened.
+		 * @param token Cancellation token indicating that opening has been canceled.
+		 *
+		 * @return Thenable indicating that the opening has completed.
+		 */
+		openExternalUri(resolvedUri: Uri, ctx: OpenExternalUriContext, token: CancellationToken): Thenable<void> | void;
+	}
+
+	/**
+	 * Additional information about the uri being opened.
+	 */
+	interface OpenExternalUriContext {
+		/**
+		 * The uri that triggered the open.
+		 *
+		 * This is the original uri that the user clicked on or that was passed to `openExternal.`
+		 * Due to port forwarding, this may not match the `resolvedUri` passed to `openExternalUri`.
+		 */
+		readonly sourceUri: Uri;
+	}
+
+	/**
+	 * Additional metadata about a registered `ExternalUriOpener`.
+	 */
+	interface ExternalUriOpenerMetadata {
+
+		/**
+		 * List of uri schemes the opener is triggered for.
+		 *
+		 * Currently only `http` and `https` are supported.
+		 */
+		readonly schemes: readonly string[];
+
+		/**
+		 * Text displayed to the user that explains what the opener does.
+		 *
+		 * For example, 'Open in browser preview'
+		 */
+		readonly label: string;
+	}
+
+	interface OpenExternalOptions {
+		/**
+		 * Allows using openers contributed by extensions through  `registerExternalUriOpener`
+		 * when opening the resource.
+		 *
+		 * If `true`, the editor will check if any contributed openers can handle the
+		 * uri, and fallback to the default opener behavior.
+		 *
+		 * If it is string, this specifies the id of the `ExternalUriOpener`
+		 * that should be used if it is available. Use `'default'` to force the editor's
+		 * standard external opener to be used.
+		 */
+		readonly allowContributedOpeners?: boolean | string;
+	}
+interface CommentThread2 {
+		/**
+		 * The uri of the document the thread has been created on.
+		 */
+		readonly uri: Uri;
+
+		/**
+		 * The range the comment thread is located within the document. The thread icon will be shown
+		 * at the last line of the range.
+		 */
+		range: Range | undefined;
+
+		/**
+		 * The ordered comments of the thread.
+		 */
+		comments: readonly Comment[];
+
+		/**
+		 * Whether the thread should be collapsed or expanded when opening the document.
+		 * Defaults to Collapsed.
+		 */
+		collapsibleState: CommentThreadCollapsibleState;
+
+		/**
+		 * Whether the thread supports reply.
+		 * Defaults to true.
+		 */
+		canReply: boolean;
+
+		/**
+		 * Context value of the comment thread. This can be used to contribute thread specific actions.
+		 * For example, a comment thread is given a context value as `editable`. When contributing actions to `comments/commentThread/title`
+		 * using `menus` extension point, you can specify context value for key `commentThread` in `when` expression like `commentThread == editable`.
+		 * ```json
+		 * "contributes": {
+		 *   "menus": {
+		 *     "comments/commentThread/title": [
+		 *       {
+		 *         "command": "extension.deleteCommentThread",
+		 *         "when": "commentThread == editable"
+		 *       }
+		 *     ]
+		 *   }
+		 * }
+		 * ```
+		 * This will show action `extension.deleteCommentThread` only for comment threads with `contextValue` is `editable`.
+		 */
+		contextValue?: string;
+
+		/**
+		 * The optional human-readable label describing the {@link CommentThread Comment Thread}
+		 */
+		label?: string;
+
+		/**
+		 * The optional state of a comment thread, which may affect how the comment is displayed.
+		 */
+		state?: CommentThreadState;
+
+		/**
+		 * Dispose this comment thread.
+		 *
+		 * Once disposed, this comment thread will be removed from visible editors and Comment Panel when appropriate.
+		 */
+		dispose(): void;
+	}
+
+	interface CommentController {
+		createCommentThread(uri: Uri, range: Range | undefined, comments: readonly Comment[]): CommentThread | CommentThread2;
+	}
+
+	interface CommentingRangeProvider2 {
+		/**
+		 * Provide a list of ranges which allow new comment threads creation or null for a given document
+		 */
+		provideCommentingRanges(document: TextDocument, token: CancellationToken): ProviderResult<Range[] | { fileComments: boolean; ranges?: Range[] }>;
+	}
+// https://github.com/microsoft/vscode/issues/73524
+
+	/**
+	 * The parameters of a query for file search.
+	 */
+	interface FileSearchQuery {
+		/**
+		 * The search pattern to match against file paths.
+		 */
+		pattern: string;
+	}
+
+	/**
+	 * Options that apply to file search.
+	 */
+	interface FileSearchOptions extends SearchOptions {
+		/**
+		 * The maximum number of results to be returned.
+		 */
+		maxResults?: number;
+
+		/**
+		 * A CancellationToken that represents the session for this search query. If the provider chooses to, this object can be used as the key for a cache,
+		 * and searches with the same session object can search the same cache. When the token is cancelled, the session is complete and the cache can be cleared.
+		 */
+		session?: CancellationToken;
+	}
+
+	/**
+	 * A FileSearchProvider provides search results for files in the given folder that match a query string. It can be invoked by quickopen or other extensions.
+	 *
+	 * A FileSearchProvider is the more powerful of two ways to implement file search in the editor. Use a FileSearchProvider if you wish to search within a folder for
+	 * all files that match the user's query.
+	 *
+	 * The FileSearchProvider will be invoked on every keypress in quickopen. When `workspace.findFiles` is called, it will be invoked with an empty query string,
+	 * and in that case, every file in the folder should be returned.
+	 */
+	interface FileSearchProvider {
+		/**
+		 * Provide the set of files that match a certain file path pattern.
+		 * @param query The parameters for this query.
+		 * @param options A set of options to consider while searching files.
+		 * @param token A cancellation token.
+		 */
+		provideFileSearchResults(query: FileSearchQuery, options: FileSearchOptions, token: CancellationToken): ProviderResult<Uri[]>;
+	}
+// https://github.com/microsoft/vscode/issues/59924
+
+	/**
+	 * Options that can be set on a findTextInFiles search.
+	 */
+	interface FindTextInFilesOptions {
+		/**
+		 * A {@link GlobPattern glob pattern} that defines the files to search for. The glob pattern
+		 * will be matched against the file paths of files relative to their workspace. Use a {@link RelativePattern relative pattern}
+		 * to restrict the search results to a {@link WorkspaceFolder workspace folder}.
+		 */
+		include?: GlobPattern;
+
+		/**
+		 * A {@link GlobPattern glob pattern} that defines files and folders to exclude. The glob pattern
+		 * will be matched against the file paths of resulting matches relative to their workspace. When `undefined`, default excludes will
+		 * apply.
+		 */
+		exclude?: GlobPattern;
+
+		/**
+		 * Whether to use the default and user-configured excludes. Defaults to true.
+		 */
+		useDefaultExcludes?: boolean;
+
+		/**
+		 * The maximum number of results to search for
+		 */
+		maxResults?: number;
+
+		/**
+		 * Whether external files that exclude files, like .gitignore, should be respected.
+		 * See the vscode setting `"search.useIgnoreFiles"`.
+		 */
+		useIgnoreFiles?: boolean;
+
+		/**
+		 * Whether global files that exclude files, like .gitignore, should be respected.
+		 * See the vscode setting `"search.useGlobalIgnoreFiles"`.
+		 */
+		useGlobalIgnoreFiles?: boolean;
+
+		/**
+		 * Whether files in parent directories that exclude files, like .gitignore, should be respected.
+		 * See the vscode setting `"search.useParentIgnoreFiles"`.
+		 */
+		useParentIgnoreFiles?: boolean;
+
+		/**
+		 * Whether symlinks should be followed while searching.
+		 * See the vscode setting `"search.followSymlinks"`.
+		 */
+		followSymlinks?: boolean;
+
+		/**
+		 * Interpret files using this encoding.
+		 * See the vscode setting `"files.encoding"`
+		 */
+		encoding?: string;
+
+		/**
+		 * Options to specify the size of the result text preview.
+		 */
+		previewOptions?: TextSearchPreviewOptions;
+
+		/**
+		 * Number of lines of context to include before each match.
+		 */
+		beforeContext?: number;
+
+		/**
+		 * Number of lines of context to include after each match.
+		 */
+		afterContext?: number;
+	}
+// https://github.com/microsoft/vscode/issues/84515
+
+	interface FileSystemProvider {
+		open?(resource: Uri, options: { create: boolean }): number | Thenable<number>;
+		close?(fd: number): void | Thenable<void>;
+		read?(fd: number, pos: number, data: Uint8Array, offset: number, length: number): number | Thenable<number>;
+		write?(fd: number, pos: number, data: Uint8Array, offset: number, length: number): number | Thenable<number>;
+	}
+// https://github.com/microsoft/vscode/issues/46726
+
+	interface IssueUriRequestHandler {
+		/**
+		 *Handle the request by the issue reporter for the Uri you want to direct the user to.
+		 */
+		handleIssueUrlRequest(): ProviderResult<Uri>;
+	}
+/**
+ * Represents a session of a currently logged in user.
+ */
+interface AuthenticationSession {
+	/**
+	 * An optional ID token that may be included in the session.
+	 */
+	readonly idToken?: string;
+}
+/**
+ * Represents a {@link TextEditor text editor}'s {@link TextEditor.options options}.
+ */
+interface TextEditorOptions {
+	/**
+	 * The size in spaces a tab takes. This is used for two purposes:
+	 *  - the rendering width of a tab character;
+	 *  - the number of spaces to insert when {@link TextEditorOptions.insertSpaces insertSpaces} is true
+	 *    and `indentSize` is set to `"tabSize"`.
+	 *
+	 * When getting a text editor's options, this property will always be a number (resolved).
+	 * When setting a text editor's options, this property is optional and it can be a number or `"auto"`.
+	 */
+	tabSize?: number | string;
+	/**
+	* The number of spaces to insert when [insertSpaces](#TextEditorOptions.insertSpaces) is true.
+	*
+	* When getting a text editor's options, this property will always be a number (resolved).
+	* When setting a text editor's options, this property is optional and it can be a number or `"tabSize"`.
+	*/
+	indentSize?: number | 'tabSize';
+}
+
+	interface InlineCompletionItem {
+		/**
+		 * If set to `true`, unopened closing brackets are removed and unclosed opening brackets are closed.
+		 * Defaults to `false`.
+		*/
+		completeBracketPairs?: boolean;
+	}
+
+	interface InlineCompletionItemProviderMetadata {
+		/**
+		 * Specifies a list of extension ids that this provider yields to if they return a result.
+		 * If some inline completion provider registered by such an extension returns a result, this provider is not asked.
+		 */
+		yieldTo: string[];
+	}
+
+	interface InlineCompletionItemProvider {
+		/**
+		 * @param completionItem The completion item that was shown.
+		 * @param updatedInsertText The actual insert text (after brackets were fixed).
+		 */
+		// eslint-disable-next-line local/vscode-dts-provider-naming
+		handleDidShowCompletionItem?(completionItem: InlineCompletionItem, updatedInsertText: string): void;
+
+		/**
+		 * Is called when an inline completion item was accepted partially.
+		 * @param acceptedLength The length of the substring of the inline completion that was accepted already.
+		 */
+		// eslint-disable-next-line local/vscode-dts-provider-naming
+		handleDidPartiallyAcceptCompletionItem?(completionItem: InlineCompletionItem, acceptedLength: number): void;
+	}
+
+	// When finalizing `commands`, make sure to add a corresponding constructor parameter.
+	interface InlineCompletionList {
+		/**
+		 * A list of commands associated with the inline completions of this list.
+		 */
+		commands?: Command[];
+
+		/**
+		 * When set and the user types a suggestion without derivating from it, the inline suggestion is not updated.
+		 * Defaults to false (might change).
+		 */
+		enableForwardStability?: boolean;
+	}
+interface InteractiveEditorSlashCommand {
+		command: string;
+		detail?: string;
+		refer?: boolean;
+		/**
+		 * Whether the command should execute as soon
+		 * as it is entered. Defaults to `false`.
+		 */
+		executeImmediately?: boolean;
+		// kind: CompletionItemKind;
+	}
+
+	// todo@API make classes
+	interface InteractiveEditorSession {
+		placeholder?: string;
+		slashCommands?: InteractiveEditorSlashCommand[];
+		wholeRange?: Range;
+		message?: string;
+	}
+
+	// todo@API make classes
+	interface InteractiveEditorRequest {
+		session: InteractiveEditorSession;
+		prompt: string;
+
+		selection: Selection;
+		wholeRange: Range;
+		attempt: number;
+		live: boolean;
+	}
+
+	// todo@API make classes
+	interface InteractiveEditorResponse {
+		edits: TextEdit[] | WorkspaceEdit;
+		placeholder?: string;
+		wholeRange?: Range;
+	}
+
+	// todo@API make classes
+	interface InteractiveEditorMessageResponse {
+		contents: MarkdownString;
+		placeholder?: string;
+		wholeRange?: Range;
+	}
+
+	declare enum InteractiveEditorResponseFeedbackKind {
+		Unhelpful = 0,
+		Helpful = 1,
+		Undone = 2,
+		Accepted = 3
+	}
+
+	interface TextDocumentContext {
+		document: TextDocument;
+		selection: Selection;
+		action?: string;
+	}
+
+	interface InteractiveEditorSessionProvider<S extends InteractiveEditorSession = InteractiveEditorSession, R extends InteractiveEditorResponse | InteractiveEditorMessageResponse = InteractiveEditorResponse | InteractiveEditorMessageResponse> {
+		label: string;
+
+		// Create a session. The lifetime of this session is the duration of the editing session with the input mode widget.
+		prepareInteractiveEditorSession(context: TextDocumentContext, token: CancellationToken): ProviderResult<S>;
+
+		provideInteractiveEditorResponse(request: InteractiveEditorRequest, token: CancellationToken): ProviderResult<R>;
+		provideInteractiveEditorResponse2?(request: InteractiveEditorRequest, progress: Progress<{ message: string; edits: TextEdit[] }>, token: CancellationToken): ProviderResult<R>;
+
+		// eslint-disable-next-line local/vscode-dts-provider-naming
+		releaseInteractiveEditorSession?(session: S): any;
+
+		// todo@API use enum instead of boolean
+		// eslint-disable-next-line local/vscode-dts-provider-naming
+		handleInteractiveEditorResponseFeedback?(session: S, response: R, kind: InteractiveEditorResponseFeedbackKind): void;
+	}
+
+
+	interface InteractiveSessionState { }
+
+	interface InteractiveSessionParticipantInformation {
+		name: string;
+
+		/**
+		 * A full URI for the icon of the participant.
+		 */
+		icon?: Uri;
+	}
+
+	interface InteractiveSession {
+		requester: InteractiveSessionParticipantInformation;
+		responder: InteractiveSessionParticipantInformation;
+		inputPlaceholder?: string;
+
+		saveState?(): InteractiveSessionState;
+	}
+
+	interface InteractiveSessionRequestArgs {
+		command: string;
+		args: any;
+	}
+interface InteractiveRequest {
+		variables: Record<string, ChatVariableValue[]>;
+	}
+
+	interface InteractiveRequest {
+		session: InteractiveSession;
+		message: string | InteractiveSessionReplyFollowup;
+	}
+
+	interface InteractiveResponseErrorDetails {
+		message: string;
+		responseIsIncomplete?: boolean;
+		responseIsFiltered?: boolean;
+	}
+
+	interface InteractiveResponseForProgress {
+		errorDetails?: InteractiveResponseErrorDetails;
+	}
+
+	interface InteractiveProgressContent {
+		content: string | MarkdownString;
+	}
+
+	interface InteractiveProgressId {
+		responseId: string;
+	}
+
+	interface InteractiveProgressTask {
+		placeholder: string;
+		resolvedContent: Thenable<InteractiveProgressContent | InteractiveProgressFileTree>;
+	}
+
+	interface FileTreeData {
+		label: string;
+		uri: Uri;
+		children?: FileTreeData[];
+	}
+
+	interface InteractiveProgressFileTree {
+		treeData: FileTreeData;
+	}
+
+	type InteractiveProgress = InteractiveProgressContent | InteractiveProgressId | InteractiveProgressTask | InteractiveProgressFileTree;
+
+	interface InteractiveResponseCommand {
+		commandId: string;
+		args?: any[];
+		title: string; // supports codicon strings
+		when?: string;
+	}
+
+	interface InteractiveSessionSlashCommand {
+		command: string;
+		kind: CompletionItemKind;
+		detail?: string;
+		shouldRepopulate?: boolean;
+		followupPlaceholder?: string;
+		executeImmediately?: boolean;
+		yieldTo?: ReadonlyArray<{ readonly command: string }>;
+	}
+
+	interface InteractiveSessionReplyFollowup {
+		message: string;
+		tooltip?: string;
+		title?: string;
+
+		// Extensions can put any serializable data here, such as an ID/version
+		metadata?: any;
+	}
+
+	type InteractiveSessionFollowup = InteractiveSessionReplyFollowup | InteractiveResponseCommand;
+
+	type InteractiveWelcomeMessageContent = string | InteractiveSessionReplyFollowup[];
+
+	interface InteractiveSessionProvider<S extends InteractiveSession = InteractiveSession> {
+		provideWelcomeMessage?(token: CancellationToken): ProviderResult<InteractiveWelcomeMessageContent[]>;
+		provideFollowups?(session: S, token: CancellationToken): ProviderResult<(string | InteractiveSessionFollowup)[]>;
+		provideSlashCommands?(session: S, token: CancellationToken): ProviderResult<InteractiveSessionSlashCommand[]>;
+
+		prepareSession(initialState: InteractiveSessionState | undefined, token: CancellationToken): ProviderResult<S>;
+		resolveRequest(session: S, context: InteractiveSessionRequestArgs | string, token: CancellationToken): ProviderResult<InteractiveRequest>;
+		provideResponseWithProgress(request: InteractiveRequest, progress: Progress<InteractiveProgress>, token: CancellationToken): ProviderResult<InteractiveResponseForProgress>;
+
+		// eslint-disable-next-line local/vscode-dts-provider-naming
+		removeRequest(session: S, requestId: string): void;
+	}
+
+	interface InteractiveSessionDynamicRequest {
+		/**
+		 * The message that will be displayed in the UI
+		 */
+		message: string;
+
+		/**
+		 * Any extra metadata/context that will go to the provider.
+		 * NOTE not actually used yet.
+		 */
+		metadata?: any;
+	}
+declare enum InteractiveSessionVoteDirection {
+		Up = 1,
+		Down = 2
+	}
+
+	interface InteractiveSessionVoteAction {
+		// eslint-disable-next-line local/vscode-dts-string-type-literals
+		kind: 'vote';
+		responseId: string;
+		direction: InteractiveSessionVoteDirection;
+	}
+
+	declare enum InteractiveSessionCopyKind {
+		// Keyboard shortcut or context menu
+		Action = 1,
+		Toolbar = 2
+	}
+
+	interface InteractiveSessionCopyAction {
+		// eslint-disable-next-line local/vscode-dts-string-type-literals
+		kind: 'copy';
+		responseId: string;
+		codeBlockIndex: number;
+		copyType: InteractiveSessionCopyKind;
+		copiedCharacters: number;
+		totalCharacters: number;
+		copiedText: string;
+	}
+
+	interface InteractiveSessionInsertAction {
+		// eslint-disable-next-line local/vscode-dts-string-type-literals
+		kind: 'insert';
+		responseId: string;
+		codeBlockIndex: number;
+		totalCharacters: number;
+		newFile?: boolean;
+	}
+
+	interface InteractiveSessionTerminalAction {
+		// eslint-disable-next-line local/vscode-dts-string-type-literals
+		kind: 'runInTerminal';
+		responseId: string;
+		codeBlockIndex: number;
+		languageId?: string;
+	}
+
+	interface InteractiveSessionCommandAction {
+		// eslint-disable-next-line local/vscode-dts-string-type-literals
+		kind: 'command';
+		command: InteractiveResponseCommand;
+	}
+
+	type InteractiveSessionUserAction = InteractiveSessionVoteAction | InteractiveSessionCopyAction | InteractiveSessionInsertAction | InteractiveSessionTerminalAction | InteractiveSessionCommandAction;
+
+	interface InteractiveSessionUserActionEvent {
+		action: InteractiveSessionUserAction;
+		providerId: string;
+	}
+
+	declare namespace interactive {
+		// current version of the proposal.
+		export const _version: 1 | number;
+
+		export function registerInteractiveSessionProvider(id: string, provider: InteractiveSessionProvider): Disposable;
+		export function addInteractiveRequest(context: InteractiveSessionRequestArgs): void;
+
+		export function sendInteractiveRequestToProvider(providerId: string, message: InteractiveSessionDynamicRequest): void;
+
+		export function registerInteractiveEditorSessionProvider(provider: InteractiveEditorSessionProvider): Disposable;
+
+		export function transferChatSession(session: InteractiveSession, toWorkspace: Uri): void;
+	}
+
+	declare namespace interactive {
+		export const onDidPerformUserAction: Event<InteractiveSessionUserActionEvent>;
+	}
+/**
+	 * The tab represents an interactive window.
+	 */
+	declare class TabInputInteractiveWindow {
+		/**
+		 * The uri of the history notebook in the interactive window.
+		 */
+		readonly uri: Uri;
+		/**
+		 * The uri of the input box in the interactive window.
+		 */
+		readonly inputBoxUri: Uri;
+		private constructor(uri: Uri, inputBoxUri: Uri);
+	}
+/**
+	 * A message passing protocol, which enables sending and receiving messages
+	 * between two parties.
+	 */
+	interface MessagePassingProtocol {
+
+		/**
+		 * Fired when a message is received from the other party.
+		 */
+		readonly onDidReceiveMessage: Event<any>;
+
+		/**
+		 * Post a message to the other party.
+		 *
+		 * @param message Body of the message. This must be a JSON serializable object.
+		 * @param transfer A collection of `ArrayBuffer` instances which can be transferred
+		 * to the other party, saving costly memory copy operations.
+		 */
+		postMessage(message: any, transfer?: ArrayBuffer[]): void;
+	}
+
+	interface ExtensionContext {
+		readonly extensionRuntime: ExtensionRuntime;
+	}
+
+	interface ExtensionContext {
+
+		/**
+		 * When not `undefined`, this is an instance of {@link MessagePassingProtocol} in
+		 * which the other party is owned by the web embedder.
+		 */
+		readonly messagePassingProtocol: MessagePassingProtocol | undefined;
+	}
+// https://github.com/microsoft/vscode/issues/173738
+
+	interface LanguageConfiguration {
+		autoClosingPairs?: {
+			open: string;
+			close: string;
+			notIn?: string[];
+		}[];
+	}
+interface RelatedContextItem {
+		readonly uri: Uri;
+		readonly range: Range;
+	}
+
+	interface MappedEditsContext {
+		selections: Selection[];
+
+		/**
+		 * If there's no context, the array should be empty. It's also empty until we figure out how to compute this or retrieve from an extension (eg, copilot chat)
+		 *
+		 * TODO: it was suggested initially to be sorted from highest priority to lowest. How would it look like?
+		 */
+		related: RelatedContextItem[];
+	}
+
+	/**
+	 * Interface for providing mapped edits for a given document.
+	 */
+	interface MappedEditsProvider {
+		/**
+		 * Provide mapped edits for a given document.
+		 * @param document The document to provide mapped edits for.
+		 * @param codeBlocks Code blocks that come from an LLM's reply.
+		 * 						"Insert at cursor" in the panel chat only sends one edit that the user clicks on, but inline chat can send multiple blocks and let the lang server decide what to do with them.
+		 * @param context The context for providing mapped edits.
+		 * @param token A cancellation token.
+		 * @returns A provider result of text edits.
+		 */
+		provideMappedEdits(
+			document: TextDocument,
+			codeBlocks: string[],
+			context: MappedEditsContext,
+			token: CancellationToken
+		): ProviderResult<WorkspaceEdit | null>;
+	}
+
+	declare namespace chat {
+
+		/**
+		 * Register a LLM as chat response provider to the editor.
+		 *
+		 *
+		 * @param id
+		 * @param provider
+		 * @param metadata
+		 */
+		export function registerChatResponseProvider(id: string, provider: ChatResponseProvider, metadata: ChatResponseProviderMetadata): Disposable;
+	}
+
+	declare namespace chat {
+
+		/**
+		 * Request access to chat.
+		 *
+		 * *Note* that this function will throw an error unless an user interaction is currently active.
+		 *
+		 * @param id The id of the chat provider, e.g `copilot`
+		 */
+		export function requestChatAccess(id: string): Thenable<ChatAccess>;
+	}
+
+	declare namespace chat {
+		export function registerSlashCommand(name: string, command: SlashCommand, metadata: SlashCommandMetadata): Disposable;
+	}
+
+	declare namespace chat {
+		export function registerVariable(name: string, description: string, resolver: ChatVariableResolver): Disposable;
+	}
+
+	declare namespace chat {
+		export function registerMappedEditsProvider(documentSelector: DocumentSelector, provider: MappedEditsProvider): Disposable;
+	}
+// https://github.com/microsoft/vscode/issues/124970
+
+	/**
+	 * The execution state of a notebook cell.
+	 */
+	declare enum NotebookCellExecutionState {
+		/**
+		 * The cell is idle.
+		 */
+		Idle = 1,
+		/**
+		 * Execution for the cell is pending.
+		 */
+		Pending = 2,
+		/**
+		 * The cell is currently executing.
+		 */
+		Executing = 3,
+	}
+
+	/**
+	 * An event describing a cell execution state change.
+	 */
+	interface NotebookCellExecutionStateChangeEvent {
+		/**
+		 * The {@link NotebookCell cell} for which the execution state has changed.
+		 */
+		readonly cell: NotebookCell;
+
+		/**
+		 * The new execution state of the cell.
+		 */
+		readonly state: NotebookCellExecutionState;
+	}
+// https://github.com/microsoft/vscode/issues/179213
+
+	declare class NotebookCodeActionKind {
+		// can only return MULTI CELL workspaceEdits
+		// ex: notebook.organizeImprots
+		static readonly Notebook: CodeActionKind;
+
+		constructor(value: string);
+	}
+// https://github.com/microsoft/vscode/issues/161144
+	declare enum NotebookControllerAffinity2 {
+		Default = 1,
+		Preferred = 2,
+		Hidden = -1
+	}
+// https://github.com/microsoft/vscode/issues/106744
+
+	interface NotebookCellOutput {
+		/**
+		 * @deprecated
+		 */
+		id: string;
+	}
+/**
+	 * A NotebookExecution is how {@link NotebookController notebook controller} can indicate whether the notebook controller is busy or not.
+	 *
+	 * When {@linkcode NotebookExecution.start start()} is called on the execution task, it causes the Notebook to enter a executing state .
+	 * When {@linkcode NotebookExecution.end end()} is called, it enters the idle state.
+	 */
+	interface NotebookExecution {
+		/**
+		 * Signal that the execution has begun.
+		 */
+		start(): void;
+
+		/**
+		 * Signal that execution has ended.
+		 */
+		end(): void;
+	}
+interface NotebookControllerDetectionTask {
+		/**
+		 * Dispose and remove the detection task.
+		 */
+		dispose(): void;
+	}
+
+	declare class NotebookKernelSourceAction {
+		readonly label: string;
+		readonly description?: string;
+		readonly detail?: string;
+		readonly command: string | Command;
+		readonly documentation?: Uri;
+
+		constructor(label: string);
+	}
+
+	interface NotebookKernelSourceActionProvider {
+		/**
+		 * An optional event to signal that the kernel source actions have changed.
+		 */
+		onDidChangeNotebookKernelSourceActions?: Event<void>;
+		/**
+		 * Provide kernel source actions
+		 */
+		provideNotebookKernelSourceActions(token: CancellationToken): ProviderResult<NotebookKernelSourceAction[]>;
+	}
+// https://github.com/microsoft/vscode/issues/106744
+
+	interface NotebookRegistrationData {
+		readonly displayName: string;
+		readonly filenamePattern: ReadonlyArray<(GlobPattern | { readonly include: GlobPattern; readonly exclude: GlobPattern })>;
+		readonly exclusive?: boolean;
+	}
+// https://github.com/microsoft/vscode/issues/123601
+
+	/**
+	 * Represents a script that is loaded into the notebook renderer before rendering output. This allows
+	 * to provide and share functionality for notebook markup and notebook output renderers.
+	 */
+	declare class NotebookRendererScript {
+
+		/**
+		 * APIs that the preload provides to the renderer. These are matched
+		 * against the `dependencies` and `optionalDependencies` arrays in the
+		 * notebook renderer contribution point.
+		 */
+		provides: readonly string[];
+
+		/**
+		 * URI of the JavaScript module to preload.
+		 *
+		 * This module must export an `activate` function that takes a context object that contains the notebook API.
+		 */
+		uri: Uri;
+
+		/**
+		 * @param uri URI of the JavaScript module to preload
+		 * @param provides Value for the `provides` property
+		 */
+		constructor(uri: Uri, provides?: string | readonly string[]);
+	}
+
+	interface NotebookController {
+		updateNotebookAffinity(notebook: NotebookDocument, affinity: NotebookControllerAffinity | NotebookControllerAffinity2): void;
+	}
+
+	interface NotebookController {
+		/**
+		 * Create an execution task.
+		 *
+		 * _Note_ that there can only be one execution per Notebook, that also includes NotebookCellExecutions and t an error is thrown if
+		 * a cell execution or another NotebookExecution is created while another is still active.
+		 *
+		 * This should be used to indicate the {@link NotebookController notebook controller} is busy even though user may not have executed any cell though the UI.
+		 * @param {NotebookDocument} notebook
+		 * @returns A notebook execution.
+		 */
+		createNotebookExecution(notebook: NotebookDocument): NotebookExecution;
+	}
+
+	interface NotebookController {
+
+		// todo@API allow add, not remove
+		readonly rendererScripts: NotebookRendererScript[];
+
+		/**
+		 * An event that fires when a {@link NotebookController.rendererScripts renderer script} has send a message to
+		 * the controller.
+		 */
+		readonly onDidReceiveMessage: Event<{ readonly editor: NotebookEditor; readonly message: any }>;
+
+		/**
+		 * Send a message to the renderer of notebook editors.
+		 *
+		 * Note that only editors showing documents that are bound to this controller
+		 * are receiving the message.
+		 *
+		 * @param message The message to send.
+		 * @param editor A specific editor to send the message to. When `undefined` all applicable editors are receiving the message.
+		 * @returns A promise that resolves to a boolean indicating if the message has been send or not.
+		 */
+		postMessage(message: any, editor?: NotebookEditor): Thenable<boolean>;
+
+		//todo@API validate this works
+		asWebviewUri(localResource: Uri): Uri;
+	}
+
+	declare namespace notebooks {
+
+		/**
+		 * An {@link Event} which fires when the execution state of a cell has changed.
+		 */
+		// todo@API this is an event that is fired for a property that cells don't have and that makes me wonder
+		// how a correct consumer works, e.g the consumer could have been late and missed an event?
+		export const onDidChangeNotebookCellExecutionState: Event<NotebookCellExecutionStateChangeEvent>;
+	}
+
+	declare namespace notebooks {
+		/**
+		 * Create notebook controller detection task
+		 */
+		export function createNotebookControllerDetectionTask(notebookType: string): NotebookControllerDetectionTask;
+
+		/**
+		 * Register a notebook kernel source action provider
+		 */
+		export function registerKernelSourceActionProvider(notebookType: string, provider: NotebookKernelSourceActionProvider): Disposable;
+	}
+
+	declare namespace notebooks {
+
+		export function createNotebookController(id: string, viewType: string, label: string, handler?: (cells: NotebookCell[], notebook: NotebookDocument, controller: NotebookController) => void | Thenable<void>, rendererScripts?: NotebookRendererScript[]): NotebookController;
+	}
+// https://github.com/microsoft/vscode/issues/126280 @mjbvz
+
+	interface NotebookCellData {
+		/**
+		 * Mime type determines how the cell's `value` is interpreted.
+		 *
+		 * The mime selects which notebook renders is used to render the cell.
+		 *
+		 * If not set, internally the cell is treated as having a mime type of `text/plain`.
+		 * Cells that set `language` to `markdown` instead are treated as `text/markdown`.
+		 */
+		mime?: string;
+	}
+
+	interface NotebookCell {
+		/**
+		 * Mime type determines how the markup cell's `value` is interpreted.
+		 *
+		 * The mime selects which notebook renders is used to render the cell.
+		 *
+		 * If not set, internally the cell is treated as having a mime type of `text/plain`.
+		 * Cells that set `language` to `markdown` instead are treated as `text/markdown`.
+		 */
+		mime: string | undefined;
+	}
+// https://github.com/microsoft/vscode/issues/115616 @alexr00
+
+	/**
+	 * The action that should be taken when a port is discovered through automatic port forwarding discovery.
+	 */
+	declare enum PortAutoForwardAction {
+		/**
+		 * Notify the user that the port is being forwarded. This is the default action.
+		 */
+		Notify = 1,
+		/**
+		 * Once the port is forwarded, open the user's web browser to the forwarded port.
+		 */
+		OpenBrowser = 2,
+		/**
+		 * Once the port is forwarded, open the preview browser to the forwarded port.
+		 */
+		OpenPreview = 3,
+		/**
+		 * Forward the port silently.
+		 */
+		Silent = 4,
+		/**
+		 * Do not forward the port.
+		 */
+		Ignore = 5
+	}
+
+	/**
+	 * The attributes that a forwarded port can have.
+	 */
+	declare class PortAttributes {
+		/**
+		 * The action to be taken when this port is detected for auto forwarding.
+		 */
+		autoForwardAction: PortAutoForwardAction;
+
+		/**
+		 * Creates a new PortAttributes object
+		 * @param port the port number
+		 * @param autoForwardAction the action to take when this port is detected
+		 */
+		constructor(autoForwardAction: PortAutoForwardAction);
+	}
+
+	/**
+	 * A provider of port attributes. Port attributes are used to determine what action should be taken when a port is discovered.
+	 */
+	interface PortAttributesProvider {
+		/**
+		 * Provides attributes for the given port. For ports that your extension doesn't know about, simply
+		 * return undefined. For example, if `providePortAttributes` is called with ports 3000 but your
+		 * extension doesn't know anything about 3000 you should return undefined.
+		 * @param port The port number of the port that attributes are being requested for.
+		 * @param pid The pid of the process that is listening on the port. If the pid is unknown, undefined will be passed.
+		 * @param commandLine The command line of the process that is listening on the port. If the command line is unknown, undefined will be passed.
+		 * @param token A cancellation token that indicates the result is no longer needed.
+		 */
+		providePortAttributes(attributes: { port: number; pid?: number; commandLine?: string }, token: CancellationToken): ProviderResult<PortAttributes>;
+	}
+
+	/**
+	 * A selector that will be used to filter which {@link PortAttributesProvider} should be called for each port.
+	 */
+	interface PortAttributesSelector {
+		/**
+		 * Specifying a port range will cause your provider to only be called for ports within the range.
+		 * The start is inclusive and the end is exclusive.
+		 */
+		portRange?: [number, number] | number;
+
+		/**
+		 * Specifying a command pattern will cause your provider to only be called for processes whose command line matches the pattern.
+		 */
+		commandPattern?: RegExp;
+	}
+interface ProfileContentHandler {
+		readonly name: string;
+		readonly description?: string;
+		saveProfile(name: string, content: string, token: CancellationToken): Thenable<{ readonly id: string; readonly link: Uri } | null>;
+		readProfile(idOrUri: string | Uri, token: CancellationToken): Thenable<string | null>;
+	}
+
+	interface QuickDiffProvider {
+		label?: string;
+	}
+// https://github.com/microsoft/vscode/issues/175662
+
+	interface QuickPickItem {
+		/**
+		 * A tooltip that is rendered when hovering over the item.
+		 */
+		tooltip?: string | MarkdownString;
+	}
+// https://github.com/microsoft/vscode/issues/73904
+
+	interface QuickPick<T extends QuickPickItem> extends QuickInput {
+		/**
+		 * An optional flag to sort the final results by index of first query match in label. Defaults to true.
+		 */
+		sortByLabel: boolean;
+	}
+//resolvers: @alexdima
+
+	interface MessageOptions {
+		/**
+		 * Do not render a native message box.
+		 */
+		useCustom?: boolean;
+	}
+
+	interface RemoteAuthorityResolverContext {
+		resolveAttempt: number;
+		/**
+		 * Exec server from a recursively-resolved remote authority. If the
+		 * remote authority includes nested authorities delimited by `@`, it is
+		 * resolved from outer to inner authorities with ExecServer passed down
+		 * to each resolver in the chain.
+		 */
+		execServer?: ExecServer;
+	}
+
+	declare class ResolvedAuthority {
+		readonly host: string;
+		readonly port: number;
+		readonly connectionToken: string | undefined;
+
+		constructor(host: string, port: number, connectionToken?: string);
+	}
+
+	interface ManagedMessagePassing {
+		onDidReceiveMessage: Event<Uint8Array>;
+		onDidClose: Event<Error | undefined>;
+		onDidEnd: Event<void>;
+
+		send: (data: Uint8Array) => void;
+		end: () => void;
+		drain?: () => Thenable<void>;
+	}
+
+	declare class ManagedResolvedAuthority {
+		readonly makeConnection: () => Thenable<ManagedMessagePassing>;
+		readonly connectionToken: string | undefined;
+
+		constructor(makeConnection: () => Thenable<ManagedMessagePassing>, connectionToken?: string);
+	}
+
+	interface ResolvedOptions {
+		extensionHostEnv?: { [key: string]: string | null };
+
+		isTrusted?: boolean;
+
+		/**
+		 * When provided, remote server will be initialized with the extensions synced using the given user account.
+		 */
+		authenticationSessionForInitializingExtensions?: AuthenticationSession & { providerId: string };
+	}
+
+	interface TunnelPrivacy {
+		themeIcon: string;
+		id: string;
+		label: string;
+	}
+
+	interface TunnelCreationOptions {
+		/**
+		 * True when the local operating system will require elevation to use the requested local port.
+		 */
+		elevationRequired?: boolean;
+	}
+
+	declare enum CandidatePortSource {
+		None = 0,
+		Process = 1,
+		Output = 2
+	}
+
+	type ResolverResult = (ResolvedAuthority | ManagedResolvedAuthority) & ResolvedOptions & TunnelInformation;
+
+	declare class RemoteAuthorityResolverError extends Error {
+		static NotAvailable(message?: string, handled?: boolean): RemoteAuthorityResolverError;
+		static TemporarilyNotAvailable(message?: string): RemoteAuthorityResolverError;
+
+		constructor(message?: string);
+	}
+
+	/**
+	 * Exec server used for nested resolvers. The type is currently not maintained
+	 * in these types, and is a contract between extensions.
+	 */
+	type ExecServer = unknown;
+
+	interface RemoteAuthorityResolver {
+		/**
+		 * Resolve the authority part of the current opened `vscode-remote://` URI.
+		 *
+		 * This method will be invoked once during the startup of the editor and again each time
+		 * the editor detects a disconnection.
+		 *
+		 * @param authority The authority part of the current opened `vscode-remote://` URI.
+		 * @param context A context indicating if this is the first call or a subsequent call.
+		 */
+		resolve(authority: string, context: RemoteAuthorityResolverContext): ResolverResult | Thenable<ResolverResult>;
+
+		/**
+		 * Resolves an exec server interface for the authority. Called if an
+		 * authority is a midpoint in a transit to the desired remote.
+		 *
+		 * @param authority The authority part of the current opened `vscode-remote://` URI.
+		 * @returns The exec server interface, as defined in a contract between extensions.
+		 */
+		resolveExecServer?(remoteAuthority: string, context: RemoteAuthorityResolverContext): ExecServer | Thenable<ExecServer>;
+
+		/**
+		 * Get the canonical URI (if applicable) for a `vscode-remote://` URI.
+		 *
+		 * @returns The canonical URI or undefined if the uri is already canonical.
+		 */
+		getCanonicalURI?(uri: Uri): ProviderResult<Uri>;
+
+		/**
+		 * Can be optionally implemented if the extension can forward ports better than the core.
+		 * When not implemented, the core will use its default forwarding logic.
+		 * When implemented, the core will use this to forward ports.
+		 *
+		 * To enable the "Change Local Port" action on forwarded ports, make sure to set the `localAddress` of
+		 * the returned `Tunnel` to a `{ port: number, host: string; }` and not a string.
+		 */
+		tunnelFactory?: (tunnelOptions: TunnelOptions, tunnelCreationOptions: TunnelCreationOptions) => Thenable<Tunnel> | undefined;
+
+		/**p
+		 * Provides filtering for candidate ports.
+		 */
+		showCandidatePort?: (host: string, port: number, detail: string) => Thenable<boolean>;
+
+		/**
+		 * @deprecated Return tunnelFeatures as part of the resolver result in tunnelInformation.
+		 */
+		tunnelFeatures?: {
+			elevation: boolean;
+			public: boolean;
+			privacyOptions: TunnelPrivacy[];
+		};
+
+		candidatePortSource?: CandidatePortSource;
+	}
+
+	interface ResourceLabelFormatter {
+		scheme: string;
+		authority?: string;
+		formatting: ResourceLabelFormatting;
+	}
+
+	interface ResourceLabelFormatting {
+		label: string; // myLabel:/${path}
+		// For historic reasons we use an or string here. Once we finalize this API we should start using enums instead and adopt it in extensions.
+		// eslint-disable-next-line local/vscode-dts-literal-or-types, local/vscode-dts-string-type-literals
+		separator: '/' | '\\' | '';
+		tildify?: boolean;
+		normalizeDriveLetter?: boolean;
+		workspaceSuffix?: string;
+		workspaceTooltip?: string;
+		authorityPrefix?: string;
+		stripPathStartingSeparator?: boolean;
+	}
+// https://github.com/microsoft/vscode/issues/133935
+
+	interface SourceControlActionButton {
+		command: Command;
+		secondaryCommands?: Command[][];
+		description?: string;
+		enabled: boolean;
+	}
+
+	interface SourceControl {
+		actionButton?: SourceControlActionButton;
+	}
+// todo@joaomoreno add issue reference
+
+	interface SourceControl {
+
+		/**
+		 * Whether the source control is selected.
+		 */
+		readonly selected: boolean;
+
+		/**
+		 * An event signaling when the selection state changes.
+		 */
+		readonly onDidChangeSelection: Event<boolean>;
+	}
+// todo@joaomoreno add issue reference
+
+	/**
+	 * Represents the validation type of the Source Control input.
+	 */
+	declare enum SourceControlInputBoxValidationType {
+
+		/**
+		 * Something not allowed by the rules of a language or other means.
+		 */
+		Error = 0,
+
+		/**
+		 * Something suspicious but allowed.
+		 */
+		Warning = 1,
+
+		/**
+		 * Something to inform about but not a problem.
+		 */
+		Information = 2
+	}
+
+	interface SourceControlInputBoxValidation {
+
+		/**
+		 * The validation message to display.
+		 */
+		readonly message: string | MarkdownString;
+
+		/**
+		 * The validation type.
+		 */
+		readonly type: SourceControlInputBoxValidationType;
+	}
+// https://github.com/microsoft/vscode/issues/166615
+
+	/**
+	 * Represents the input box in the Source Control viewlet.
+	 */
+	interface SourceControlInputBox {
+
+		/**
+		 * The {@link TextDocument text} of the input box.
+		 */
+		readonly document: TextDocument;
+	}
+
+	/**
+	 * Represents the input box in the Source Control viewlet.
+	 */
+	interface SourceControlInputBox {
+
+		/**
+		 * Shows a transient contextual message on the input.
+		 */
+		showValidationMessage(message: string | MarkdownString, type: SourceControlInputBoxValidationType): void;
+
+		/**
+		 * A validation function for the input box. It's possible to change
+		 * the validation provider simply by setting this property to a different function.
+		 */
+		validateInput?(value: string, cursorPosition: number): ProviderResult<SourceControlInputBoxValidation>;
+	}
+/**
+	 * Data about an item which can be shared.
+	 */
+	interface ShareableItem {
+		/**
+		 * A resource in the workspace that can be shared.
+		 */
+		resourceUri: Uri;
+
+		/**
+		 * If present, a selection within the `resourceUri`.
+		 */
+		selection?: Range;
+	}
+
+	/**
+	 * A provider which generates share links for resources in the editor.
+	 */
+	interface ShareProvider {
+
+		/**
+		 * A unique ID for the provider.
+		 * This will be used to activate specific extensions contributing share providers if necessary.
+		 */
+		readonly id: string;
+
+		/**
+		 * A label which will be used to present this provider's options in the UI.
+		 */
+		readonly label: string;
+
+		/**
+		 * The order in which the provider should be listed in the UI when there are multiple providers.
+		 */
+		readonly priority: number;
+
+		/**
+		 *
+		 * @param item Data about an item which can be shared.
+		 * @param token A cancellation token.
+		 * @returns A {@link Uri} representing an external link or sharing text. The provider result
+		 * will be copied to the user's clipboard and presented in a confirmation dialog.
+		 */
+		provideShare(item: ShareableItem, token: CancellationToken): ProviderResult<Uri | string>;
+	}
+
+	interface TreeItem {
+
+		/**
+		 * An optional property which, when set, inlines a `Share` option in the context menu for this tree item.
+		 */
+		shareableItem?: ShareableItem;
+	}
+interface OpenDialogOptions {
+	/**
+	 * Controls whether the dialog allows users to select local files via the "Show Local" button.
+	 * Extensions that set this to `true` should check the scheme of the selected file.
+	 * Resources with the `file` scheme come from the same extension host as the extension.
+	 * Resources with the `vscode-local` scheme come from an extension host running in the same place as the UI.
+	 */
+	allowUIResources?: boolean;
+}
+declare class TabInputTextMerge {
+
+		readonly base: Uri;
+		readonly input1: Uri;
+		readonly input2: Uri;
+		readonly result: Uri;
+
+		constructor(base: Uri, input1: Uri, input2: Uri, result: Uri);
+	}
+
+	interface Tab {
+		readonly input: TabInputText | TabInputTextDiff | TabInputCustom | TabInputWebview | TabInputNotebook | TabInputNotebookDiff | TabInputTerminal | TabInputInteractiveWindow | unknown;
+	}
+
+	interface Tab {
+
+		readonly input: TabInputText | TabInputTextDiff | TabInputTextMerge | TabInputCustom | TabInputWebview | TabInputNotebook | TabInputNotebookDiff | TabInputTerminal | unknown;
+
+	}
+// https://github.com/microsoft/vscode/issues/47265
+
+	interface TaskPresentationOptions {
+		/**
+		 * Controls whether the task is executed in a specific terminal group using split panes.
+		 */
+		group?: string;
+	}
+interface TelemetryConfiguration {
+		/**
+		 * Whether or not usage telemetry collection is allowed
+		 */
+		readonly isUsageEnabled: boolean;
+		/**
+		 * Whether or not crash error telemetry collection is allowed
+		 */
+		readonly isErrorsEnabled: boolean;
+		/**
+		 * Whether or not crash report collection is allowed
+		 */
+		readonly isCrashEnabled: boolean;
+	}
+// See https://github.com/microsoft/vscode/issues/160694
+	declare namespace env {
+
+		/**
+		 * An {@link Event} which fires when the default shell changes.
+		 */
+		export const onDidChangeShell: Event<string>;
+	}
+
+	declare namespace env {
+		export function openExternal(target: Uri, options?: OpenExternalOptions): Thenable<boolean>;
+	}
+
+	declare namespace env {
+		/**
+		 * Register an {@link IssueUriRequestHandler}. By registering an issue uri request handler,
+		 * you can direct the built-in issue reporter to your issue reporting web experience of choice.
+		 * The Uri that the handler returns will be opened in the user's browser.
+		 *
+		 * Examples of this include:
+		 * - Using GitHub Issue Forms or GitHub Discussions you can pre-fill the issue creation with relevant information from the current workspace using query parameters
+		 * - Directing to a different web form that isn't on GitHub for reporting issues
+		 *
+		 * @param handler the issue uri request handler to register for this extension.
+		 */
+		export function registerIssueUriRequestHandler(handler: IssueUriRequestHandler): Disposable;
+	}
+
+	declare namespace env {
+		/** Quality of the application. May be undefined if running from sources. */
+		export const appQuality: string | undefined;
+		/** Commit of the application. May be undefined if running from sources. */
+		export const appCommit: string | undefined;
+	}
+
+	declare namespace env {
+
+		/**
+		 * The authority part of the current opened `vscode-remote://` URI.
+		 * Defined by extensions, e.g. `ssh-remote+${host}` for remotes using a secure shell.
+		 *
+		 * *Note* that the value is `undefined` when there is no remote extension host but that the
+		 * value is defined in all extension hosts (local and remote) in case a remote extension host
+		 * exists. Use {@link Extension.extensionKind} to know if
+		 * a specific extension runs remote or not.
+		 */
+		export const remoteAuthority: string | undefined;
+
+	}
+
+	declare namespace env {
+		/**
+		 * Indicates what telemetry is enabled / disabled
+		 * Can be observed to determine what telemetry the extension is allowed to send
+		 */
+		export const telemetryConfiguration: TelemetryConfiguration;
+
+		/**
+		 * An {@link Event} which fires when the collectable state of telemetry changes
+		 * Returns a {@link TelemetryConfiguration} object
+		 */
+		export const onDidChangeTelemetryConfiguration: Event<TelemetryConfiguration | undefined>;
+	}
+
+// https://github.com/microsoft/vscode/issues/78502
+	//
+	// This API is still proposed but we don't intent on promoting it to stable due to problems
+	// around performance. See #145234 for a more likely API to get stabilized.
+
+	interface TerminalDataWriteEvent {
+		/**
+		 * The {@link Terminal} for which the data was written.
+		 */
+		readonly terminal: Terminal;
+		/**
+		 * The data being written.
+		 */
+		readonly data: string;
+	}
+// https://github.com/microsoft/vscode/issues/55718
+
+	/**
+	 * An {@link Event} which fires when a {@link Terminal}'s dimensions change.
+	 */
+	interface TerminalDimensionsChangeEvent {
+		/**
+		 * The {@link Terminal} for which the dimensions have changed.
+		 */
+		readonly terminal: Terminal;
+		/**
+		 * The new value for the {@link Terminal.dimensions terminal's dimensions}.
+		 */
+		readonly dimensions: TerminalDimensions;
+	}
+// https://github.com/microsoft/vscode/issues/145234
+
+	interface TerminalExecutedCommand {
+		/**
+		 * The {@link Terminal} the command was executed in.
+		 */
+		terminal: Terminal;
+		/**
+		 * The full command line that was executed, including both the command and the arguments.
+		 */
+		commandLine: string | undefined;
+		/**
+		 * The current working directory that was reported by the shell. This will be a {@link Uri}
+		 * if the string reported by the shell can reliably be mapped to the connected machine.
+		 */
+		cwd: Uri | string | undefined;
+		/**
+		 * The exit code reported by the shell.
+		 */
+		exitCode: number | undefined;
+		/**
+		 * The output of the command when it has finished executing. This is the plain text shown in
+		 * the terminal buffer and does not include raw escape sequences. Depending on the shell
+		 * setup, this may include the command line as part of the output.
+		 */
+		output: string | undefined;
+	}
+// https://github.com/microsoft/vscode/issues/162950
+
+	type SingleOrMany<T> = T[] | T;
+
+	interface TerminalQuickFixProvider {
+		/**
+		 * Provides terminal quick fixes
+		 * @param commandMatchResult The command match result for which to provide quick fixes
+		 * @param token A cancellation token indicating the result is no longer needed
+		 * @return Terminal quick fix(es) if any
+		 */
+		provideTerminalQuickFixes(commandMatchResult: TerminalCommandMatchResult, token: CancellationToken): ProviderResult<SingleOrMany<TerminalQuickFixExecuteTerminalCommand | TerminalQuickFixOpener | Command>>;
+	}
+
+
+	interface TerminalCommandMatchResult {
+		commandLine: string;
+		commandLineMatch: RegExpMatchArray;
+		outputMatch?: {
+			regexMatch: RegExpMatchArray;
+			outputLines: string[];
+		};
+	}
+
+	declare namespace window {
+		export function createWebviewTextEditorInset(editor: TextEditor, line: number, height: number, options?: WebviewOptions): WebviewEditorInset;
+	}
+
+	declare namespace window {
+		/**
+		 * Register a new `ExternalUriOpener`.
+		 *
+		 * When a uri is about to be opened, an `onOpenExternalUri:SCHEME` activation event is fired.
+		 *
+		 * @param id Unique id of the opener, such as `myExtension.browserPreview`. This is used in settings
+		 *   and commands to identify the opener.
+		 * @param opener Opener to register.
+		 * @param metadata Additional information about the opener.
+		 *
+		* @returns Disposable that unregisters the opener.
+		*/
+		export function registerExternalUriOpener(id: string, opener: ExternalUriOpener, metadata: ExternalUriOpenerMetadata): Disposable;
+	}
+
+	declare namespace window {
+		export function registerProfileContentHandler(id: string, profileContentHandler: ProfileContentHandler): Disposable;
+	}
+// https://github.com/microsoft/vscode/issues/169012
+
+	declare namespace window {
+		export function registerQuickDiffProvider(selector: DocumentSelector, quickDiffProvider: QuickDiffProvider, label: string, rootUri?: Uri): Disposable;
+	}
+
+	declare namespace window {
+
+		/**
+		 * Register a share provider. An extension may register multiple share providers.
+		 * There may be multiple share providers for the same {@link ShareableItem}.
+		 * @param selector A document selector to filter whether the provider should be shown for a {@link ShareableItem}.
+		 * @param provider A share provider.
+		 */
+		export function registerShareProvider(selector: DocumentSelector, provider: ShareProvider): Disposable;
+	}
+
+	declare namespace window {
+		/**
+		 * An event which fires when the terminal's child pseudo-device is written to (the shell).
+		 * In other words, this provides access to the raw data stream from the process running
+		 * within the terminal, including VT sequences.
+		 */
+		export const onDidWriteTerminalData: Event<TerminalDataWriteEvent>;
+	}
+
+	declare namespace window {
+		/**
+		 * An event which fires when the {@link Terminal.dimensions dimensions} of the terminal change.
+		 */
+		export const onDidChangeTerminalDimensions: Event<TerminalDimensionsChangeEvent>;
+	}
+
+	declare namespace window {
+		/**
+		 * An event that is emitted when a terminal with shell integration activated has completed
+		 * executing a command.
+		 *
+		 * Note that this event will not fire if the executed command exits the shell, listen to
+		 * {@link onDidCloseTerminal} to handle that case.
+		 */
+		export const onDidExecuteTerminalCommand: Event<TerminalExecutedCommand>;
+	}
+
+	declare namespace window {
+		/**
+			 * @param provider A terminal quick fix provider
+			 * @return A {@link Disposable} that unregisters the provider when being disposed
+			 */
+		export function registerTerminalQuickFixProvider(id: string, provider: TerminalQuickFixProvider): Disposable;
+	}
+
+	declare class TerminalQuickFixExecuteTerminalCommand {
+		/**
+		 * The terminal command to run
+		 */
+		terminalCommand: string;
+		constructor(terminalCommand: string);
+	}
+	declare class TerminalQuickFixOpener {
+		/**
+		 * The uri to open
+		 */
+		uri: Uri;
+		constructor(uri: Uri);
+	}
+
+	/**
+	 * A matcher that runs on a sub-section of a terminal command's output
+	 */
+	interface TerminalOutputMatcher {
+		/**
+		 * A string or regex to match against the unwrapped line. If this is a regex with the multiline
+		 * flag, it will scan an amount of lines equal to `\n` instances in the regex + 1.
+		 */
+		lineMatcher: string | RegExp;
+		/**
+		 * Which side of the output to anchor the {@link offset} and {@link length} against.
+		 */
+		anchor: TerminalOutputAnchor;
+		/**
+			 * The number of rows above or below the {@link anchor} to start matching against.
+			 */
+		offset: number;
+		/**
+		 * The number of wrapped lines to match against, this should be as small as possible for performance
+		 * reasons. This is capped at 40.
+		 */
+		length: number;
+	}
+
+	declare enum TerminalOutputAnchor {
+		Top = 0,
+		Bottom = 1
+	}
+
+	interface Terminal {
+		/**
+		 * The current dimensions of the terminal. This will be `undefined` immediately after the
+		 * terminal is created as the dimensions are not known until shortly after the terminal is
+		 * created.
+		 */
+		readonly dimensions: TerminalDimensions | undefined;
+	}
+// https://github.com/microsoft/vscode/issues/188173
+
+	interface Terminal {
+		/**
+		 * The selected text of the terminal or undefined if there is no selection.
+		 */
+		readonly selection: string | undefined;
+	}
+// https://github.com/microsoft/vscode/issues/123713
+
+	interface TestRun {
+		/**
+		 * Test coverage provider for this result. An extension can defer setting
+		 * this until after a run is complete and coverage is available.
+		 */
+		coverageProvider?: TestCoverageProvider;
+		// ...
+	}
+
+	/**
+	 * Provides information about test coverage for a test result.
+	 * Methods on the provider will not be called until the test run is complete
+	 */
+	interface TestCoverageProvider<T extends FileCoverage = FileCoverage> {
+		/**
+		 * Returns coverage information for all files involved in the test run.
+		 * @param token A cancellation token.
+		 * @return Coverage metadata for all files involved in the test.
+		 */
+		provideFileCoverage(token: CancellationToken): ProviderResult<T[]>;
+
+		/**
+		 * Give a FileCoverage to fill in more data, namely {@link FileCoverage.detailedCoverage}.
+		 * The editor will only resolve a FileCoverage once, and only if detailedCoverage
+		 * is undefined.
+		 *
+		 * @param coverage A coverage object obtained from {@link provideFileCoverage}
+		 * @param token A cancellation token.
+		 * @return The resolved file coverage, or a thenable that resolves to one. It
+		 * is OK to return the given `coverage`. When no result is returned, the
+		 * given `coverage` will be used.
+		 */
+		resolveFileCoverage?(coverage: T, token: CancellationToken): ProviderResult<T>;
+	}
+
+	/**
+	 * A class that contains information about a covered resource. A count can
+	 * be give for lines, branches, and functions in a file.
+	 */
+	declare class CoveredCount {
+		/**
+		 * Number of items covered in the file.
+		 */
+		covered: number;
+		/**
+		 * Total number of covered items in the file.
+		 */
+		total: number;
+
+		/**
+		 * @param covered Value for {@link CovereredCount.covered}
+		 * @param total Value for {@link CovereredCount.total}
+		 */
+		constructor(covered: number, total: number);
+	}
+
+	/**
+	 * Contains coverage metadata for a file.
+	 */
+	declare class FileCoverage {
+		/**
+		 * File URI.
+		 */
+		readonly uri: Uri;
+
+		/**
+		 * Statement coverage information. If the reporter does not provide statement
+		 * coverage information, this can instead be used to represent line coverage.
+		 */
+		statementCoverage: CoveredCount;
+
+		/**
+		 * Branch coverage information.
+		 */
+		branchCoverage?: CoveredCount;
+
+		/**
+		 * Function coverage information.
+		 */
+		functionCoverage?: CoveredCount;
+
+		/**
+		 * Detailed, per-statement coverage. If this is undefined, the editor will
+		 * call {@link TestCoverageProvider.resolveFileCoverage} when necessary.
+		 */
+		detailedCoverage?: DetailedCoverage[];
+
+		/**
+		 * Creates a {@link FileCoverage} instance with counts filled in from
+		 * the coverage details.
+		 * @param uri Covered file URI
+		 * @param detailed Detailed coverage information
+		 */
+		static fromDetails(uri: Uri, details: readonly DetailedCoverage[]): FileCoverage;
+
+		/**
+		 * @param uri Covered file URI
+		 * @param statementCoverage Statement coverage information. If the reporter
+		 * does not provide statement coverage information, this can instead be
+		 * used to represent line coverage.
+		 * @param branchCoverage Branch coverage information
+		 * @param functionCoverage Function coverage information
+		 */
+		constructor(
+			uri: Uri,
+			statementCoverage: CoveredCount,
+			branchCoverage?: CoveredCount,
+			functionCoverage?: CoveredCount,
+		);
+	}
+
+	/**
+	 * Contains coverage information for a single statement or line.
+	 */
+	declare class StatementCoverage {
+		/**
+		 * The number of times this statement was executed. If zero, the
+		 * statement will be marked as un-covered.
+		 */
+		executionCount: number;
+
+		/**
+		 * Statement location.
+		 */
+		location: Position | Range;
+
+		/**
+		 * Coverage from branches of this line or statement. If it's not a
+		 * conditional, this will be empty.
+		 */
+		branches: BranchCoverage[];
+
+		/**
+		 * @param location The statement position.
+		 * @param executionCount The number of times this statement was
+		 * executed. If zero, the statement will be marked as un-covered.
+		 * @param branches Coverage from branches of this line.  If it's not a
+		 * conditional, this should be omitted.
+		 */
+		constructor(executionCount: number, location: Position | Range, branches?: BranchCoverage[]);
+	}
+
+	/**
+	 * Contains coverage information for a branch of a {@link StatementCoverage}.
+	 */
+	declare class BranchCoverage {
+		/**
+		 * The number of times this branch was executed. If zero, the
+		 * branch will be marked as un-covered.
+		 */
+		executionCount: number;
+
+		/**
+		 * Branch location.
+		 */
+		location?: Position | Range;
+
+		/**
+		 * @param executionCount The number of times this branch was executed.
+		 * @param location The branch position.
+		 */
+		constructor(executionCount: number, location?: Position | Range);
+	}
+
+	/**
+	 * Contains coverage information for a function or method.
+	 */
+	declare class FunctionCoverage {
+		/**
+		 * The number of times this function was executed. If zero, the
+		 * function will be marked as un-covered.
+		 */
+		executionCount: number;
+
+		/**
+		 * Function location.
+		 */
+		location: Position | Range;
+
+		/**
+		 * @param executionCount The number of times this function was executed.
+		 * @param location The function position.
+		 */
+		constructor(executionCount: number, location: Position | Range);
+	}
+
+	type DetailedCoverage = StatementCoverage | FunctionCoverage;
+// https://github.com/microsoft/vscode/issues/190277
+
+	declare class TestMessage2 extends TestMessage {
+
+		/**
+		 * Context value of the test item. This can be used to contribute message-
+		 * specific actions to the test peek view. The value set here can be found
+		 * in the `testMessage` property of the following `menus` contribution points:
+		 *
+		 * - `testing/message/context` - context menu for the message in the results tree
+		 * - `testing/message/content` - a prominent button overlaying editor content where
+		 *    the message is displayed.
+		 *
+		 * For example:
+		 *
+		 * ```json
+		 * "contributes": {
+		 *   "menus": {
+		 *     "testing/message/content": [
+		 *       {
+		 *         "command": "extension.deleteCommentThread",
+		 *         "when": "testMessage == canApplyRichDiff"
+		 *       }
+		 *     ]
+		 *   }
+		 * }
+		 * ```
+		 *
+		 * The command will be called with an object containing:
+		 * - `test`: the {@link TestItem} the message is associated with, *if* it
+		 *    is still present in the {@link TestController.items} collection.
+		 * - `message`: the {@link TestMessage} instance.
+		 */
+		contextValue?: string;
+
+		// ...
+	}
+// https://github.com/microsoft/vscode/issues/107467
+
+	declare namespace tests {
+		/**
+		 * Requests that tests be run by their controller.
+		 * @param run Run options to use.
+		 * @param token Cancellation token for the test run
+		 */
+		export function runTests(run: TestRunRequest, token?: CancellationToken): Thenable<void>;
+
+		/**
+		 * Returns an observer that watches and can request tests.
+		 */
+		export function createTestObserver(): TestObserver;
+		/**
+		 * List of test results stored by the editor, sorted in descending
+		 * order by their `completedAt` time.
+		 */
+		export const testResults: ReadonlyArray<TestRunResult>;
+
+		/**
+		 * Event that fires when the {@link testResults} array is updated.
+		 */
+		export const onDidChangeTestResults: Event<void>;
+	}
+
+	interface TestObserver {
+		/**
+		 * List of tests returned by test provider for files in the workspace.
+		 */
+		readonly tests: ReadonlyArray<TestItem>;
+
+		/**
+		 * An event that fires when an existing test in the collection changes, or
+		 * null if a top-level test was added or removed. When fired, the consumer
+		 * should check the test item and all its children for changes.
+		 */
+		readonly onDidChangeTest: Event<TestsChangeEvent>;
+
+		/**
+		 * Dispose of the observer, allowing the editor to eventually tell test
+		 * providers that they no longer need to update tests.
+		 */
+		dispose(): void;
+	}
+
+	interface TestsChangeEvent {
+		/**
+		 * List of all tests that are newly added.
+		 */
+		readonly added: ReadonlyArray<TestItem>;
+
+		/**
+		 * List of existing tests that have updated.
+		 */
+		readonly updated: ReadonlyArray<TestItem>;
+
+		/**
+		 * List of existing tests that have been removed.
+		 */
+		readonly removed: ReadonlyArray<TestItem>;
+	}
+
+	/**
+	 * TestResults can be provided to the editor in {@link tests.publishTestResult},
+	 * or read from it in {@link tests.testResults}.
+	 *
+	 * The results contain a 'snapshot' of the tests at the point when the test
+	 * run is complete. Therefore, information such as its {@link Range} may be
+	 * out of date. If the test still exists in the workspace, consumers can use
+	 * its `id` to correlate the result instance with the living test.
+	 */
+	interface TestRunResult {
+		/**
+		 * Unix milliseconds timestamp at which the test run was completed.
+		 */
+		readonly completedAt: number;
+
+		/**
+		 * Optional raw output from the test run.
+		 */
+		readonly output?: string;
+
+		/**
+		 * List of test results. The items in this array are the items that
+		 * were passed in the {@link tests.runTests} method.
+		 */
+		readonly results: ReadonlyArray<Readonly<TestResultSnapshot>>;
+	}
+
+	/**
+	 * A {@link TestItem}-like interface with an associated result, which appear
+	 * or can be provided in {@link TestResult} interfaces.
+	 */
+	interface TestResultSnapshot {
+		/**
+		 * Unique identifier that matches that of the associated TestItem.
+		 * This is used to correlate test results and tests in the document with
+		 * those in the workspace (test explorer).
+		 */
+		readonly id: string;
+
+		/**
+		 * Parent of this item.
+		 */
+		readonly parent?: TestResultSnapshot;
+
+		/**
+		 * URI this TestItem is associated with. May be a file or file.
+		 */
+		readonly uri?: Uri;
+
+		/**
+		 * Display name describing the test case.
+		 */
+		readonly label: string;
+
+		/**
+		 * Optional description that appears next to the label.
+		 */
+		readonly description?: string;
+
+		/**
+		 * Location of the test item in its `uri`. This is only meaningful if the
+		 * `uri` points to a file.
+		 */
+		readonly range?: Range;
+
+		/**
+		 * State of the test in each task. In the common case, a test will only
+		 * be executed in a single task and the length of this array will be 1.
+		 */
+		readonly taskStates: ReadonlyArray<TestSnapshotTaskState>;
+
+		/**
+		 * Optional list of nested tests for this item.
+		 */
+		readonly children: Readonly<TestResultSnapshot>[];
+	}
+
+	interface TestSnapshotTaskState {
+		/**
+		 * Current result of the test.
+		 */
+		readonly state: TestResultState;
+
+		/**
+		 * The number of milliseconds the test took to run. This is set once the
+		 * `state` is `Passed`, `Failed`, or `Errored`.
+		 */
+		readonly duration?: number;
+
+		/**
+		 * Associated test run message. Can, for example, contain assertion
+		 * failure information if the test fails.
+		 */
+		readonly messages: ReadonlyArray<TestMessage>;
+	}
+
+	/**
+	 * Possible states of tests in a test run.
+	 */
+	declare enum TestResultState {
+		// Test will be run, but is not currently running.
+		Queued = 1,
+		// Test is currently running
+		Running = 2,
+		// Test run has passed
+		Passed = 3,
+		// Test run has failed (on an assertion)
+		Failed = 4,
+		// Test run has been skipped
+		Skipped = 5,
+		// Test run failed for some other reason (compilation error, timeout, etc)
+		Errored = 6
+	}
+// https://github.com/microsoft/vscode/issues/59921
+
+	/**
+	 * The parameters of a query for text search.
+	 */
+	interface TextSearchQuery {
+		/**
+		 * The text pattern to search for.
+		 */
+		pattern: string;
+
+		/**
+		 * Whether or not `pattern` should match multiple lines of text.
+		 */
+		isMultiline?: boolean;
+
+		/**
+		 * Whether or not `pattern` should be interpreted as a regular expression.
+		 */
+		isRegExp?: boolean;
+
+		/**
+		 * Whether or not the search should be case-sensitive.
+		 */
+		isCaseSensitive?: boolean;
+
+		/**
+		 * Whether or not to search for whole word matches only.
+		 */
+		isWordMatch?: boolean;
+	}
+
+	/**
+	 * A file glob pattern to match file paths against.
+	 * TODO@roblourens merge this with the GlobPattern docs/definition in vscode.d.ts.
+	 * @see {@link GlobPattern}
+	 */
+	type GlobString = string;
+
+	/**
+	 * Options common to file and text search
+	 */
+	interface SearchOptions {
+		/**
+		 * The root folder to search within.
+		 */
+		folder: Uri;
+
+		/**
+		 * Files that match an `includes` glob pattern should be included in the search.
+		 */
+		includes: GlobString[];
+
+		/**
+		 * Files that match an `excludes` glob pattern should be excluded from the search.
+		 */
+		excludes: GlobString[];
+
+		/**
+		 * Whether external files that exclude files, like .gitignore, should be respected.
+		 * See the vscode setting `"search.useIgnoreFiles"`.
+		 */
+		useIgnoreFiles: boolean;
+
+		/**
+		 * Whether symlinks should be followed while searching.
+		 * See the vscode setting `"search.followSymlinks"`.
+		 */
+		followSymlinks: boolean;
+
+		/**
+		 * Whether global files that exclude files, like .gitignore, should be respected.
+		 * See the vscode setting `"search.useGlobalIgnoreFiles"`.
+		 */
+		useGlobalIgnoreFiles: boolean;
+
+		/**
+		 * Whether files in parent directories that exclude files, like .gitignore, should be respected.
+		 * See the vscode setting `"search.useParentIgnoreFiles"`.
+		 */
+		useParentIgnoreFiles: boolean;
+	}
+
+	/**
+	 * Options to specify the size of the result text preview.
+	 * These options don't affect the size of the match itself, just the amount of preview text.
+	 */
+	interface TextSearchPreviewOptions {
+		/**
+		 * The maximum number of lines in the preview.
+		 * Only search providers that support multiline search will ever return more than one line in the match.
+		 */
+		matchLines: number;
+
+		/**
+		 * The maximum number of characters included per line.
+		 */
+		charsPerLine: number;
+	}
+
+	/**
+	 * Options that apply to text search.
+	 */
+	interface TextSearchOptions extends SearchOptions {
+		/**
+		 * The maximum number of results to be returned.
+		 */
+		maxResults: number;
+
+		/**
+		 * Options to specify the size of the result text preview.
+		 */
+		previewOptions?: TextSearchPreviewOptions;
+
+		/**
+		 * Exclude files larger than `maxFileSize` in bytes.
+		 */
+		maxFileSize?: number;
+
+		/**
+		 * Interpret files using this encoding.
+		 * See the vscode setting `"files.encoding"`
+		 */
+		encoding?: string;
+
+		/**
+		 * Number of lines of context to include before each match.
+		 */
+		beforeContext?: number;
+
+		/**
+		 * Number of lines of context to include after each match.
+		 */
+		afterContext?: number;
+	}
+
+	/**
+	 * Represents the severity of a TextSearchComplete message.
+	 */
+	declare enum TextSearchCompleteMessageType {
+		Information = 1,
+		Warning = 2,
+	}
+
+	/**
+	 * A message regarding a completed search.
+	 */
+	interface TextSearchCompleteMessage {
+		/**
+		 * Markdown text of the message.
+		 */
+		text: string;
+		/**
+		 * Whether the source of the message is trusted, command links are disabled for untrusted message sources.
+		 * Messaged are untrusted by default.
+		 */
+		trusted?: boolean;
+		/**
+		 * The message type, this affects how the message will be rendered.
+		 */
+		type: TextSearchCompleteMessageType;
+	}
+
+	/**
+	 * Information collected when text search is complete.
+	 */
+	interface TextSearchComplete {
+		/**
+		 * Whether the search hit the limit on the maximum number of search results.
+		 * `maxResults` on {@linkcode TextSearchOptions} specifies the max number of results.
+		 * - If exactly that number of matches exist, this should be false.
+		 * - If `maxResults` matches are returned and more exist, this should be true.
+		 * - If search hits an internal limit which is less than `maxResults`, this should be true.
+		 */
+		limitHit?: boolean;
+
+		/**
+		 * Additional information regarding the state of the completed search.
+		 *
+		 * Messages with "Information" style support links in markdown syntax:
+		 * - Click to [run a command](command:workbench.action.OpenQuickPick)
+		 * - Click to [open a website](https://aka.ms)
+		 *
+		 * Commands may optionally return { triggerSearch: true } to signal to the editor that the original search should run be again.
+		 */
+		message?: TextSearchCompleteMessage | TextSearchCompleteMessage[];
+	}
+
+	/**
+	 * A preview of the text result.
+	 */
+	interface TextSearchMatchPreview {
+		/**
+		 * The matching lines of text, or a portion of the matching line that contains the match.
+		 */
+		text: string;
+
+		/**
+		 * The Range within `text` corresponding to the text of the match.
+		 * The number of matches must match the TextSearchMatch's range property.
+		 */
+		matches: Range | Range[];
+	}
+
+	/**
+	 * A match from a text search
+	 */
+	interface TextSearchMatch {
+		/**
+		 * The uri for the matching document.
+		 */
+		uri: Uri;
+
+		/**
+		 * The range of the match within the document, or multiple ranges for multiple matches.
+		 */
+		ranges: Range | Range[];
+
+		/**
+		 * A preview of the text match.
+		 */
+		preview: TextSearchMatchPreview;
+	}
+
+	/**
+	 * A line of context surrounding a TextSearchMatch.
+	 */
+	interface TextSearchContext {
+		/**
+		 * The uri for the matching document.
+		 */
+		uri: Uri;
+
+		/**
+		 * One line of text.
+		 * previewOptions.charsPerLine applies to this
+		 */
+		text: string;
+
+		/**
+		 * The line number of this line of context.
+		 */
+		lineNumber: number;
+	}
+
+	type TextSearchResult = TextSearchMatch | TextSearchContext;
+
+	/**
+	 * A TextSearchProvider provides search results for text results inside files in the workspace.
+	 */
+	interface TextSearchProvider {
+		/**
+		 * Provide results that match the given text pattern.
+		 * @param query The parameters for this query.
+		 * @param options A set of options to consider while searching.
+		 * @param progress A progress callback that must be invoked for all results.
+		 * @param token A cancellation token.
+		 */
+		provideTextSearchResults(query: TextSearchQuery, options: TextSearchOptions, progress: Progress<TextSearchResult>, token: CancellationToken): ProviderResult<TextSearchComplete>;
+	}
+// https://github.com/microsoft/vscode/issues/84297
+
+	declare class TimelineItem {
+		/**
+		 * A timestamp (in milliseconds since 1 January 1970 00:00:00) for when the timeline item occurred.
+		 */
+		timestamp: number;
+
+		/**
+		 * A human-readable string describing the timeline item.
+		 */
+		label: string;
+
+		/**
+		 * Optional id for the timeline item. It must be unique across all the timeline items provided by this source.
+		 *
+		 * If not provided, an id is generated using the timeline item's timestamp.
+		 */
+		id?: string;
+
+		/**
+		 * The icon path or {@link ThemeIcon} for the timeline item.
+		 */
+		iconPath?: Uri | { light: Uri; dark: Uri } | ThemeIcon;
+
+		/**
+		 * A human readable string describing less prominent details of the timeline item.
+		 */
+		description?: string;
+
+		/**
+		 * The tooltip text when you hover over the timeline item.
+		 */
+		tooltip?: string | MarkdownString | undefined;
+
+		/**
+		 * The {@link Command} that should be executed when the timeline item is selected.
+		 */
+		command?: Command;
+
+		/**
+		 * Context value of the timeline item. This can be used to contribute specific actions to the item.
+		 * For example, a timeline item is given a context value as `commit`. When contributing actions to `timeline/item/context`
+		 * using `menus` extension point, you can specify context value for key `timelineItem` in `when` expression like `timelineItem == commit`.
+		 * ```
+		 *	"contributes": {
+		 *		"menus": {
+		 *			"timeline/item/context": [
+		 *				{
+		 *					"command": "extension.copyCommitId",
+		 *					"when": "timelineItem == commit"
+		 *				}
+		 *			]
+		 *		}
+		 *	}
+		 * ```
+		 * This will show the `extension.copyCommitId` action only for items where `contextValue` is `commit`.
+		 */
+		contextValue?: string;
+
+		/**
+		 * Accessibility information used when screen reader interacts with this timeline item.
+		 */
+		accessibilityInformation?: AccessibilityInformation;
+
+		/**
+		 * @param label A human-readable string describing the timeline item
+		 * @param timestamp A timestamp (in milliseconds since 1 January 1970 00:00:00) for when the timeline item occurred
+		 */
+		constructor(label: string, timestamp: number);
+	}
+
+	interface TimelineChangeEvent {
+		/**
+		 * The {@link Uri} of the resource for which the timeline changed.
+		 */
+		uri: Uri;
+
+		/**
+		 * A flag which indicates whether the entire timeline should be reset.
+		 */
+		reset?: boolean;
+	}
+
+	interface Timeline {
+		readonly paging?: {
+			/**
+			 * A provider-defined cursor specifying the starting point of timeline items which are after the ones returned.
+			 * Use `undefined` to signal that there are no more items to be returned.
+			 */
+			readonly cursor: string | undefined;
+		};
+
+		/**
+		 * An array of {@link TimelineItem timeline items}.
+		 */
+		readonly items: readonly TimelineItem[];
+	}
+
+	interface TimelineOptions {
+		/**
+		 * A provider-defined cursor specifying the starting point of the timeline items that should be returned.
+		 */
+		cursor?: string;
+
+		/**
+		 * An optional maximum number timeline items or the all timeline items newer (inclusive) than the timestamp or id that should be returned.
+		 * If `undefined` all timeline items should be returned.
+		 */
+		limit?: number | { timestamp: number; id?: string };
+	}
+
+	interface TimelineProvider {
+		/**
+		 * An optional event to signal that the timeline for a source has changed.
+		 * To signal that the timeline for all resources (uris) has changed, do not pass any argument or pass `undefined`.
+		 */
+		onDidChange?: Event<TimelineChangeEvent | undefined>;
+
+		/**
+		 * An identifier of the source of the timeline items. This can be used to filter sources.
+		 */
+		readonly id: string;
+
+		/**
+		 * A human-readable string describing the source of the timeline items. This can be used as the display label when filtering sources.
+		 */
+		readonly label: string;
+
+		/**
+		 * Provide {@link TimelineItem timeline items} for a {@link Uri}.
+		 *
+		 * @param uri The {@link Uri} of the file to provide the timeline for.
+		 * @param options A set of options to determine how results should be returned.
+		 * @param token A cancellation token.
+		 * @return The {@link TimelineResult timeline result} or a thenable that resolves to such. The lack of a result
+		 * can be signaled by returning `undefined`, `null`, or an empty array.
+		 */
+		provideTimeline(uri: Uri, options: TimelineOptions, token: CancellationToken): ProviderResult<Timeline>;
+	}
+// https://github.com/microsoft/vscode/issues/91555
+
+	declare enum StandardTokenType {
+		Other = 0,
+		Comment = 1,
+		String = 2,
+		RegEx = 3
+	}
+
+	interface TokenInformation {
+		type: StandardTokenType;
+		range: Range;
+	}
+
+	declare namespace languages {
+		export function registerDocumentPasteEditProvider(selector: DocumentSelector, provider: DocumentPasteEditProvider, metadata: DocumentPasteProviderMetadata): Disposable;
+	}
+
+	declare namespace languages {
+		export function registerDocumentDropEditProvider(selector: DocumentSelector, provider: DocumentDropEditProvider, metadata?: DocumentDropEditProviderMetadata): Disposable;
+	}
+// https://github.com/microsoft/vscode/issues/124024 @hediet @alexdima
+
+	declare namespace languages {
+		/**
+		 * Registers an inline completion provider.
+		 *
+		 * Multiple providers can be registered for a language. In that case providers are asked in
+		 * parallel and the results are merged. A failing provider (rejected promise or exception) will
+		 * not cause a failure of the whole operation.
+		 *
+		 * @param selector A selector that defines the documents this provider is applicable to.
+		 * @param provider An inline completion provider.
+		 * @param metadata Metadata about the provider.
+		 * @return A {@link Disposable} that unregisters this provider when being disposed.
+		 */
+		export function registerInlineCompletionItemProvider(selector: DocumentSelector, provider: InlineCompletionItemProvider, metadata: InlineCompletionItemProviderMetadata): Disposable;
+	}
+
+	declare namespace languages {
+		/** @deprecated */
+		export function getTokenInformationAtPosition(document: TextDocument, position: Position): Thenable<TokenInformation>;
+	}
+
+	/**
+	 * The event that is fired when there is a change in {@link TreeView.activeItem tree view's active item}
+	 */
+	interface TreeViewActiveItemChangeEvent<T> {
+		/**
+		 * Active item.
+		 */
+		readonly activeItem: T | undefined;
+	}
+interface TreeView2<T> extends Disposable {
+		readonly onDidExpandElement: Event<TreeViewExpansionEvent<T>>;
+		readonly onDidCollapseElement: Event<TreeViewExpansionEvent<T>>;
+		readonly selection: readonly T[];
+		readonly onDidChangeSelection: Event<TreeViewSelectionChangeEvent<T>>;
+		readonly visible: boolean;
+		readonly onDidChangeVisibility: Event<TreeViewVisibilityChangeEvent>;
+		readonly onDidChangeCheckboxState: Event<TreeCheckboxChangeEvent<T>>;
+		title?: string;
+		description?: string;
+		badge?: ViewBadge | undefined;
+		reveal(element: T, options?: { select?: boolean; focus?: boolean; expand?: boolean | number }): Thenable<void>;
+
+		/**
+		 * An optional human-readable message that will be rendered in the view.
+		 * Only a subset of markdown is supported.
+		 * Setting the message to null, undefined, or empty string will remove the message from the view.
+		 */
+		message?: string | MarkdownString;
+	}
+// https://github.com/microsoft/vscode/issues/170248
+
+	interface TreeView<T> extends Disposable {
+		/**
+		 * Currently active item.
+		 */
+		readonly activeItem: T | undefined;
+		/**
+		 * Event that is fired when the {@link TreeView.activeItem active item} has changed
+		 */
+		readonly onDidChangeActiveItem: Event<TreeViewActiveItemChangeEvent<T>>;
+	}
+// https://github.com/microsoft/vscode/issues/61313 @alexr00
+
+	interface TreeView<T> extends Disposable {
+		reveal(element: T | undefined, options?: { select?: boolean; focus?: boolean; expand?: boolean | number }): Thenable<void>;
+	}
+
+	/**
+	 * Used as part of the ResolverResult if the extension has any candidate,
+	 * published, or forwarded ports.
+	 */
+	interface TunnelInformation {
+		/**
+		 * Tunnels that are detected by the extension. The remotePort is used for display purposes.
+		 * The localAddress should be the complete local address (ex. localhost:1234) for connecting to the port. Tunnels provided through
+		 * detected are read-only from the forwarded ports UI.
+		 */
+		environmentTunnels?: TunnelDescription[];
+
+		tunnelFeatures?: {
+			elevation: boolean;
+			/**
+			 * One of the the options must have the ID "private".
+			 */
+			privacyOptions: TunnelPrivacy[];
+		};
+	}
+/**
+	 * Used as part of the ResolverResult if the extension has any candidate,
+	 * published, or forwarded ports.
+	 */
+	interface TunnelInformation {
+		/**
+		 * Tunnels that are detected by the extension. The remotePort is used for display purposes.
+		 * The localAddress should be the complete local address (ex. localhost:1234) for connecting to the port. Tunnels provided through
+		 * environmentTunnels are read-only from the forwarded ports UI.
+		 */
+		environmentTunnels?: TunnelDescription[];
+
+		tunnelFeatures?: {
+			elevation: boolean;
+			/**
+			 * One of the the options must have the ID "private".
+			 */
+			privacyOptions: TunnelPrivacy[];
+		};
+	}
+
+	interface TunnelProvider {
+		/**
+		 * Provides port forwarding capabilities. If there is a resolver that already provids tunnels, then the resolver's provider will
+		 * be used. If multiple providers are registered, then only the first will be used.
+		 */
+		provideTunnel(tunnelOptions: TunnelOptions, tunnelCreationOptions: TunnelCreationOptions, token: CancellationToken): ProviderResult<Tunnel>;
+	}
+
+	interface TunnelOptions {
+		remoteAddress: { port: number; host: string };
+		// The desired local port. If this port can't be used, then another will be chosen.
+		localAddressPort?: number;
+		label?: string;
+		/**
+		 * @deprecated Use privacy instead
+		 */
+		public?: boolean;
+		privacy?: string;
+		protocol?: string;
+	}
+// tunnels @alexr00
+
+	interface TunnelOptions {
+		remoteAddress: { port: number; host: string };
+		// The desired local port. If this port can't be used, then another will be chosen.
+		localAddressPort?: number;
+		label?: string;
+		/**
+		 * @deprecated Use privacy instead
+		 */
+		public?: boolean;
+		privacy?: string;
+		protocol?: string;
+	}
+
+	interface TunnelDescription {
+		remoteAddress: { port: number; host: string };
+		//The complete local address(ex. localhost:1234)
+		localAddress: { port: number; host: string } | string;
+		/**
+		 * @deprecated Use privacy instead
+		 */
+		public?: boolean;
+		privacy?: string;
+		// If protocol is not provided it is assumed to be http, regardless of the localAddress.
+		protocol?: string;
+	}
+
+	interface TunnelDescription {
+		remoteAddress: { port: number; host: string };
+		//The complete local address(ex. localhost:1234)
+		localAddress: { port: number; host: string } | string;
+		/**
+		 * @deprecated Use privacy instead
+		 */
+		public?: boolean;
+		privacy?: string;
+		// If protocol is not provided it is assumed to be http, regardless of the localAddress.
+		protocol?: string;
+	}
+
+	interface Tunnel extends TunnelDescription {
+		// Implementers of Tunnel should fire onDidDispose when dispose is called.
+		onDidDispose: Event<void>;
+		dispose(): void | Thenable<void>;
+	}
+
+	interface Tunnel extends TunnelDescription {
+		// Implementers of Tunnel should fire onDidDispose when dispose is called.
+		onDidDispose: Event<void>;
+		dispose(): void | Thenable<void>;
+	}
+// https://github.com/microsoft/vscode/issues/181569 @connor4312
+
+	interface WindowState {
+		/**
+		 * Indicates whether the window has been interacted with recently. This will
+		 * change immediately on activity, or after a short time of user inactivity.
+		 */
+		readonly active: boolean;
+	}
+// https://github.com/microsoft/vscode/issues/120173
+
+	/**
+	 * The object describing the properties of the workspace trust request
+	 */
+	interface WorkspaceTrustRequestOptions {
+		/**
+		 * Custom message describing the user action that requires workspace
+		 * trust. If omitted, a generic message will be displayed in the workspace
+		 * trust request dialog.
+		 */
+		readonly message?: string;
+	}
+// https://github.com/microsoft/vscode/issues/180582
+
+	declare namespace workspace {
+		/**
+		 *
+		 * @param scheme The URI scheme that this provider can provide canonical URIs for.
+		 * A canonical URI represents the conversion of a resource's alias into a source of truth URI.
+		 * Multiple aliases may convert to the same source of truth URI.
+		 * @param provider A provider which can convert URIs of scheme @param scheme to
+		 * a canonical URI which is stable across machines.
+		 */
+		export function registerCanonicalUriProvider(scheme: string, provider: CanonicalUriProvider): Disposable;
+
+		/**
+		 *
+		 * @param uri The URI to provide a canonical URI for.
+		 * @param token A cancellation token for the request.
+		 */
+		export function getCanonicalUri(uri: Uri, options: CanonicalUriRequestOptions, token: CancellationToken): ProviderResult<Uri>;
+	}
+// https://github.com/microsoft/vscode/issues/157734
+
+	declare namespace workspace {
+		/**
+		 * An event that is emitted when an edit session identity is about to be requested.
+		 */
+		export const onWillCreateEditSessionIdentity: Event<EditSessionIdentityWillCreateEvent>;
+
+		/**
+		 *
+		 * @param scheme The URI scheme that this provider can provide edit session identities for.
+		 * @param provider A provider which can convert URIs for workspace folders of scheme @param scheme to
+		 * an edit session identifier which is stable across machines. This enables edit sessions to be resolved.
+		 */
+		export function registerEditSessionIdentityProvider(scheme: string, provider: EditSessionIdentityProvider): Disposable;
+	}
+
+	declare namespace workspace {
+		/**
+		 * Register a search provider.
+		 *
+		 * Only one provider can be registered per scheme.
+		 *
+		 * @param scheme The provider will be invoked for workspace folders that have this file scheme.
+		 * @param provider The provider.
+		 * @return A {@link Disposable} that unregisters this provider when being disposed.
+		 */
+		export function registerFileSearchProvider(scheme: string, provider: FileSearchProvider): Disposable;
+	}
+
+	declare namespace workspace {
+		/**
+		 * Search text in files across all {@link workspace.workspaceFolders workspace folders} in the workspace.
+		 * @param query The query parameters for the search - the search string, whether it's case-sensitive, or a regex, or matches whole words.
+		 * @param callback A callback, called for each result
+		 * @param token A token that can be used to signal cancellation to the underlying search engine.
+		 * @return A thenable that resolves when the search is complete.
+		 */
+		export function findTextInFiles(query: TextSearchQuery, callback: (result: TextSearchResult) => void, token?: CancellationToken): Thenable<TextSearchComplete>;
+
+		/**
+		 * Search text in files across all {@link workspace.workspaceFolders workspace folders} in the workspace.
+		 * @param query The query parameters for the search - the search string, whether it's case-sensitive, or a regex, or matches whole words.
+		 * @param options An optional set of query options. Include and exclude patterns, maxResults, etc.
+		 * @param callback A callback, called for each result
+		 * @param token A token that can be used to signal cancellation to the underlying search engine.
+		 * @return A thenable that resolves when the search is complete.
+		 */
+		export function findTextInFiles(query: TextSearchQuery, options: FindTextInFilesOptions, callback: (result: TextSearchResult) => void, token?: CancellationToken): Thenable<TextSearchComplete>;
+	}
+
+	declare namespace workspace {
+
+		// SPECIAL overload with NotebookRegistrationData
+		export function registerNotebookSerializer(notebookType: string, serializer: NotebookSerializer, options?: NotebookDocumentContentOptions, registration?: NotebookRegistrationData): Disposable;
+	}
+
+	declare namespace workspace {
+		/**
+		 * If your extension listens on ports, consider registering a PortAttributesProvider to provide information
+		 * about the ports. For example, a debug extension may know about debug ports in it's debuggee. By providing
+		 * this information with a PortAttributesProvider the extension can tell the editor that these ports should be
+		 * ignored, since they don't need to be user facing.
+		 *
+		 * The results of the PortAttributesProvider are merged with the user setting `remote.portsAttributes`. If the values conflict, the user setting takes precedence.
+		 *
+		 * @param portSelector It is best practice to specify a port selector to avoid unnecessary calls to your provider.
+		 * If you don't specify a port selector your provider will be called for every port, which will result in slower port forwarding for the user.
+		 * @param provider The {@link PortAttributesProvider PortAttributesProvider}.
+		 */
+		export function registerPortAttributesProvider(portSelector: PortAttributesSelector, provider: PortAttributesProvider): Disposable;
+	}
+declare namespace workspace {
+
+		export function registerFileSystemProvider(scheme: string, provider: FileSystemProvider, options?: { readonly isCaseSensitive?: boolean; readonly isReadonly?: boolean | MarkdownString }): Disposable;
+	}
+
+	declare namespace workspace {
+		export function registerRemoteAuthorityResolver(authorityPrefix: string, resolver: RemoteAuthorityResolver): Disposable;
+		export function registerResourceLabelFormatter(formatter: ResourceLabelFormatter): Disposable;
+		export function getRemoteExecServer(authority: string): Thenable<ExecServer | undefined>;
+	}
+declare namespace workspace {
+
+		/**
+		 * Saves the editor identified by the given resource and returns the resulting resource or `undefined`
+		 * if save was not successful or no editor with the given resource was found.
+		 *
+		 * **Note** that an editor with the provided resource must be opened in order to be saved.
+		 *
+		 * @param uri the associated uri for the opened editor to save.
+		 * @return A thenable that resolves when the save operation has finished.
+		 */
+		export function save(uri: Uri): Thenable<Uri | undefined>;
+
+		/**
+		 * Saves the editor identified by the given resource to a new file name as provided by the user and
+		 * returns the resulting resource or `undefined` if save was not successful or cancelled or no editor
+		 * with the given resource was found.
+		 *
+		 * **Note** that an editor with the provided resource must be opened in order to be saved as.
+		 *
+		 * @param uri the associated uri for the opened editor to save as.
+		 * @return A thenable that resolves when the save-as operation has finished.
+		 */
+		export function saveAs(uri: Uri): Thenable<Uri | undefined>;
+	}
+
+	declare namespace workspace {
+		/**
+		 * Register a text search provider.
+		 *
+		 * Only one provider can be registered per scheme.
+		 *
+		 * @param scheme The provider will be invoked for workspace folders that have this file scheme.
+		 * @param provider The provider.
+		 * @return A {@link Disposable} that unregisters this provider when being disposed.
+		 */
+		export function registerTextSearchProvider(scheme: string, provider: TextSearchProvider): Disposable;
+	}
+
+	declare namespace workspace {
+		/**
+		 * Register a timeline provider.
+		 *
+		 * Multiple providers can be registered. In that case, providers are asked in
+		 * parallel and the results are merged. A failing provider (rejected promise or exception) will
+		 * not cause a failure of the whole operation.
+		 *
+		 * @param scheme A scheme or schemes that defines which documents this provider is applicable to. Can be `*` to target all documents.
+		 * @param provider A timeline provider.
+		 * @return A {@link Disposable} that unregisters this provider when being disposed.
+		*/
+		export function registerTimelineProvider(scheme: string | string[], provider: TimelineProvider): Disposable;
+	}
+
+	declare namespace workspace {
+		/**
+		 * Registering a tunnel provider enables port forwarding. This will cause the Ports view to show.
+		 * @param provider
+		 */
+		export function registerTunnelProvider(provider: TunnelProvider, information: TunnelInformation): Thenable<Disposable>;
+	}
+
+	declare namespace workspace {
+		/**
+		 * Forwards a port. If the current resolver implements RemoteAuthorityResolver:forwardPort then that will be used to make the tunnel.
+		 * By default, openTunnel only support localhost; however, RemoteAuthorityResolver:tunnelFactory can be used to support other ips.
+		 *
+		 * @throws When run in an environment without a remote.
+		 *
+		 * @param tunnelOptions The `localPort` is a suggestion only. If that port is not available another will be chosen.
+		 */
+		export function openTunnel(tunnelOptions: TunnelOptions): Thenable<Tunnel>;
+
+		/**
+		 * Gets an array of the currently available tunnels. This does not include environment tunnels, only tunnels that have been created by the user.
+		 * Note that these are of type TunnelDescription and cannot be disposed.
+		 */
+		export let tunnels: Thenable<TunnelDescription[]>;
+
+		/**
+		 * Fired when the list of tunnels has changed.
+		 */
+		export const onDidChangeTunnels: Event<void>;
+	}
+
+	declare namespace workspace {
+		/**
+		 * Prompt the user to chose whether to trust the current workspace
+		 * @param options Optional object describing the properties of the
+		 * workspace trust request.
+		 */
+		export function requestWorkspaceTrust(options?: WorkspaceTrustRequestOptions): Thenable<boolean | undefined>;
+	}
+
+export { type AuthenticationForceNewSessionOptions, type AuthenticationProvider, type AuthenticationProviderCreateSessionOptions, type AuthenticationSession, BranchCoverage, CandidatePortSource, type CanonicalUriProvider, type CanonicalUriRequestOptions, type ChatAccess, ChatMessage, ChatMessageRole, type ChatResponseFragment, type ChatResponseProvider, type ChatResponseProviderMetadata, type ChatVariableContext, ChatVariableLevel, type ChatVariableResolver, type ChatVariableValue, type CommandInformationResult, type Comment, type CommentController, CommentState, type CommentThread2, type CommentingRangeProvider2, CoveredCount, type CustomTextEditorProvider, type DetailedCoverage, type DocumentDropEdit, type DocumentDropEditProviderMetadata, type DocumentFilter, DocumentPasteEdit, type DocumentPasteEditProvider, type DocumentPasteProviderMetadata, EditSessionIdentityMatch, type EditSessionIdentityProvider, type EditSessionIdentityWillCreateEvent, type EmbeddingVectorProvider, type ExecServer, type Extension, type ExtensionContext, ExtensionRuntime, type ExternalUriOpener, type ExternalUriOpenerMetadata, ExternalUriOpenerPriority, FileCoverage, FileDecoration2, type FileSearchOptions, type FileSearchProvider, type FileSearchQuery, type FileSystemProvider, type FileTreeData, type FindTextInFilesOptions, FunctionCoverage, type GlobString, type InlineCompletionItem, type InlineCompletionItemProvider, type InlineCompletionItemProviderMetadata, type InlineCompletionList, type InteractiveEditorMessageResponse, type InteractiveEditorRequest, type InteractiveEditorResponse, InteractiveEditorResponseFeedbackKind, type InteractiveEditorSession, type InteractiveEditorSessionProvider, type InteractiveEditorSlashCommand, type InteractiveProgress, type InteractiveProgressContent, type InteractiveProgressFileTree, type InteractiveProgressId, type InteractiveProgressTask, type InteractiveRequest, type InteractiveResponseCommand, type InteractiveResponseErrorDetails, type InteractiveResponseForProgress, type InteractiveSession, type InteractiveSessionCommandAction, type InteractiveSessionCopyAction, InteractiveSessionCopyKind, type InteractiveSessionDynamicRequest, type InteractiveSessionFollowup, type InteractiveSessionInsertAction, type InteractiveSessionParticipantInformation, type InteractiveSessionProvider, type InteractiveSessionReplyFollowup, type InteractiveSessionRequestArgs, type InteractiveSessionSlashCommand, type InteractiveSessionState, type InteractiveSessionTerminalAction, type InteractiveSessionUserAction, type InteractiveSessionUserActionEvent, type InteractiveSessionVoteAction, InteractiveSessionVoteDirection, type InteractiveWelcomeMessageContent, type IssueUriRequestHandler, type LanguageConfiguration, type LineChange, type ManagedMessagePassing, ManagedResolvedAuthority, type MappedEditsContext, type MappedEditsProvider, type MessageOptions, type MessagePassingProtocol, type NotebookCell, type NotebookCellData, NotebookCellExecutionState, type NotebookCellExecutionStateChangeEvent, type NotebookCellOutput, NotebookCodeActionKind, type NotebookController, NotebookControllerAffinity2, type NotebookControllerDetectionTask, type NotebookDocumentContentOptions, type NotebookExecution, NotebookKernelSourceAction, type NotebookKernelSourceActionProvider, type NotebookRegistrationData, NotebookRendererScript, type OpenDialogOptions, type OpenExternalOptions, type OpenExternalUriContext, PortAttributes, type PortAttributesProvider, type PortAttributesSelector, PortAutoForwardAction, type ProfileContentHandler, type QuickDiffProvider, type QuickPick, type QuickPickItem, type RelatedContextItem, type RelatedInformationBaseResult, type RelatedInformationProvider, type RelatedInformationResult, RelatedInformationType, type RemoteAuthorityResolver, type RemoteAuthorityResolverContext, RemoteAuthorityResolverError, ResolvedAuthority, type ResolvedOptions, type ResolverResult, type ResourceLabelFormatter, type ResourceLabelFormatting, type SearchOptions, type SettingInformationResult, type ShareProvider, type ShareableItem, type SingleOrMany, type SlashCommand, type SlashCommandContext, type SlashCommandMetadata, type SlashResponse, type SlashResult, type SourceControl, type SourceControlActionButton, type SourceControlInputBox, type SourceControlInputBoxValidation, SourceControlInputBoxValidationType, StackFrameFocus, StandardTokenType, StatementCoverage, type Tab, TabInputInteractiveWindow, TabInputTextMerge, type TaskPresentationOptions, type TelemetryConfiguration, type Terminal, type TerminalCommandMatchResult, type TerminalDataWriteEvent, type TerminalDimensionsChangeEvent, type TerminalExecutedCommand, TerminalOutputAnchor, type TerminalOutputMatcher, TerminalQuickFixExecuteTerminalCommand, TerminalQuickFixOpener, type TerminalQuickFixProvider, type TestCoverageProvider, TestMessage2, type TestObserver, type TestResultSnapshot, TestResultState, type TestRun, type TestRunResult, type TestSnapshotTaskState, type TestsChangeEvent, type TextDocumentContext, type TextEditorOptions, type TextSearchComplete, type TextSearchCompleteMessage, TextSearchCompleteMessageType, type TextSearchContext, type TextSearchMatch, type TextSearchMatchPreview, type TextSearchOptions, type TextSearchPreviewOptions, type TextSearchProvider, type TextSearchQuery, type TextSearchResult, ThreadFocus, type Timeline, type TimelineChangeEvent, TimelineItem, type TimelineOptions, type TimelineProvider, type TokenInformation, type TreeItem, type TreeView, type TreeView2, type TreeViewActiveItemChangeEvent, type Tunnel, type TunnelCreationOptions, type TunnelDescription, type TunnelInformation, type TunnelOptions, type TunnelPrivacy, type TunnelProvider, type WebviewEditorInset, type WindowState, type WorkspaceTrustRequestOptions, ai, authentication, chat, commands, debug, env, extensions, interactive, languages, notebooks, tests, window, workspace };