@codingame/monaco-vscode-api 3.2.3 → 4.0.0

package/vscode-dts/vscode.proposed.documentPaste.d.ts

@@ -8,55 +8,106 @@ declare module 'vscode' {
 	// https://github.com/microsoft/vscode/issues/30066/
 
 	/**
-	 * Provider invoked when the user copies and pastes code.
+	 * The reason why paste edits were requested.
 	 */
-	interface DocumentPasteEditProvider {
+	export enum DocumentPasteTriggerKind {
+		/**
+		 * Pasting was requested as part of a normal paste operation.
+		 */
+		Automatic = 0,
+
+		/**
+		 * Pasting was requested by the user with the `paste as` command.
+		 */
+		PasteAs = 1,
+	}
+
+	/**
+	 * Additional information about the paste operation.
+	 */
+
+	export interface DocumentPasteEditContext {
+		/**
+		 * Requested kind of paste edits to return.
+		 */
+		readonly only: DocumentPasteEditKind | undefined;
+
+		/**
+		 * The reason why paste edits were requested.
+		 */
+		readonly triggerKind: DocumentPasteTriggerKind;
+	}
+
+	/**
+	 * Provider invoked when the user copies or pastes in a {@linkcode TextDocument}.
+	 */
+	interface DocumentPasteEditProvider<T extends DocumentPasteEdit = DocumentPasteEdit> {
 
 		/**
 		 * 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}.
+		 * This allows the provider to attach copy metadata to the {@link DataTransfer}
+		 * which is then passed back to providers in {@linkcode provideDocumentPasteEdits}.
+		 *
+		 * Note that currently any changes to the {@linkcode DataTransfer} are isolated to the current editor session.
+		 * This means that added metadata cannot be seen by other applications.
 		 *
 		 * @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 ranges Ranges being copied in {@linkcode document}.
+		 * @param dataTransfer The data transfer associated with the copy. You can store additional values on this for later use in  {@linkcode provideDocumentPasteEdits}.
+		 * This object is only valid for the duration of this method.
 		 * @param token A cancellation token.
+		 *
+		 * @return Optional thenable that resolves when all changes to the `dataTransfer` are complete.
 		 */
 		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.
+		 * Returned edits can replace 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 ranges Range in the {@linkcode document} to paste into.
+		 * @param dataTransfer The {@link DataTransfer data transfer} associated with the paste. This object is only valid for the duration of the paste operation.
+		 * @param context Additional context for the paste.
 		 * @param token A cancellation token.
 		 *
-		 * @return Optional workspace edit that applies the paste. Return undefined to use standard pasting.
+		 * @return Set of potential {@link DocumentPasteEdit edits} that apply the paste. Return `undefined` to use standard pasting.
 		 */
-		provideDocumentPasteEdits?(document: TextDocument, ranges: readonly Range[], dataTransfer: DataTransfer, token: CancellationToken): ProviderResult<DocumentPasteEdit>;
+		provideDocumentPasteEdits?(document: TextDocument, ranges: readonly Range[], dataTransfer: DataTransfer, context: DocumentPasteEditContext, token: CancellationToken): ProviderResult<T[]>;
+
+		/**
+		 * Optional method which fills in the {@linkcode DocumentPasteEdit.additionalEdit} before the edit is applied.
+		 *
+		 * This is called once per edit and should be used if generating the complete edit may take a long time.
+		 * Resolve can only be used to change {@link DocumentPasteEdit.additionalEdit}.
+		 *
+		 * @param pasteEdit The {@linkcode DocumentPasteEdit} to resolve.
+		 * @param token A cancellation token.
+		 *
+		 * @returns The resolved paste edit or a thenable that resolves to such. It is OK to return the given
+		 * `pasteEdit`. If no result is returned, the given `pasteEdit` is used.
+		 */
+		resolveDocumentPasteEdit?(pasteEdit: T, token: CancellationToken): ProviderResult<T>;
 	}
 
 	/**
-	 * An operation applied on paste
+	 * An edit applied on paste.
 	 */
 	class DocumentPasteEdit {
 
 		/**
 		 * Human readable label that describes the edit.
 		 */
-		label: string;
+		title: string;
 
 		/**
-		 * Controls the ordering or multiple paste edits. If this provider yield to edits, it will be shown lower in the list.
+		 * {@link DocumentPasteEditKind Kind} of the edit.
+		 *
+		 * Used to identify specific types of edits.
 		 */
-		yieldTo?: ReadonlyArray<
-			| { readonly extensionId: string; readonly providerId: string }
-			| { readonly mimeType: string }
-		>;
+		kind: DocumentPasteEditKind;
 
 		/**
 		 * The text or snippet to insert at the pasted locations.
@@ -69,43 +120,77 @@ declare module 'vscode' {
 		additionalEdit?: WorkspaceEdit;
 
 		/**
-		 * @param insertText The text or snippet to insert at the pasted locations.
+		 * Controls the ordering of paste edits provided by multiple providers.
+		 *
+		 * If this edit yields to another, it will be shown lower in the list of paste edit.
+		 */
+		yieldTo?: readonly DocumentPasteEditKind[];
+
+		/**
+		 * Create a new paste edit.
 		 *
-		 * TODO: Reverse args, but this will break existing consumers :(
+		 * @param insertText The text or snippet to insert at the pasted locations.
+		 * @param title Human readable label that describes the edit.
+		 * @param kind {@link DocumentPasteEditKind Kind} of the edit.
 		 */
-		constructor(insertText: string | SnippetString, label: string);
+		constructor(insertText: string | SnippetString, title: string, kind: DocumentPasteEditKind);
+	}
+
+
+	/**
+	 * TODO: Share with code action kind?
+	 */
+	class DocumentPasteEditKind {
+		static readonly Empty: DocumentPasteEditKind;
+
+		// TODO: Add `Text` any others?
+
+		private constructor(value: string);
+
+		readonly value: string;
+
+		append(...parts: string[]): CodeActionKind;
+		intersects(other: CodeActionKind): boolean;
+		contains(other: CodeActionKind): boolean;
 	}
 
 	interface DocumentPasteProviderMetadata {
 		/**
-		 * Identifies the provider.
-		 *
-		 * This id is used when users configure the default provider for paste.
+		 * List of {@link DocumentPasteEditKind kinds} that the provider may return in {@linkcode DocumentPasteEditProvider.provideDocumentPasteEdits provideDocumentPasteEdits}.
 		 *
-		 * This id should be unique within the extension but does not need to be unique across extensions.
+		 * The provider will only be invoked when one of these kinds is being requested. For normal pasting, all providers will be invoked.
 		 */
-		readonly id: string;
+		readonly providedPasteEditKinds: readonly DocumentPasteEditKind[];
 
 		/**
-		 * Mime types that {@link DocumentPasteEditProvider.prepareDocumentPaste provideDocumentPasteEdits} may add on copy.
+		 * Mime types that {@linkcode DocumentPasteEditProvider.prepareDocumentPaste prepareDocumentPaste} may add on copy.
 		 */
 		readonly copyMimeTypes?: readonly string[];
 
 		/**
-		 * Mime types that {@link DocumentPasteEditProvider.provideDocumentPasteEdits provideDocumentPasteEdits} should be invoked for.
+		 * Mime types that {@linkcode 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
+		 * Use `files` to indicate that the provider should be invoked if any {@link DataTransferFile files} are present in the {@linkcode DataTransfer}.
+		 * Note that {@linkcode DataTransferFile} entries are only created when dropping content from outside the editor, such as
 		 * from the operating system.
 		 */
 		readonly pasteMimeTypes?: readonly string[];
 	}
 
 	namespace languages {
+		/**
+		 * Registers a new {@linkcode DocumentPasteEditProvider}.
+		 *
+		 * @param selector A selector that defines the documents this provider applies to.
+		 * @param provider A paste editor provider.
+		 * @param metadata Additional metadata about the provider.
+		 *
+		 * @returns A {@link Disposable} that unregisters this provider when disposed of.
+		 */
 		export function registerDocumentPasteEditProvider(selector: DocumentSelector, provider: DocumentPasteEditProvider, metadata: DocumentPasteProviderMetadata): Disposable;
 	}
 }

package/vscode-dts/vscode.proposed.dropMetadata.d.ts

@@ -7,11 +7,27 @@ declare module 'vscode' {
 
 	// https://github.com/microsoft/vscode/issues/179430
 
+
+	/**
+	 * TODO:
+	 * - Add ctor(insertText: string | SnippetString, title?: string, kind?: DocumentPasteEditKind); Can't be done as this is an extension to an existing class
+	 * - Update provider to return multiple edits
+	 */
+
 	export interface DocumentDropEdit {
 		/**
 		 * Human readable label that describes the edit.
 		 */
-		label?: string;
+		title?: string;
+
+		/**
+		 * {@link DocumentPasteEditKind Kind} of the edit.
+		 *
+		 * Used to identify specific types of edits.
+		 *
+		 * TODO: use own type?
+		 */
+		kind: DocumentPasteEditKind;
 
 		/**
 		 * The mime type from the {@link DataTransfer} that this edit applies.
@@ -23,22 +39,11 @@ declare module 'vscode' {
 		/**
 		 * 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 }
-		>;
+		yieldTo?: ReadonlyArray<DocumentPasteEditKind>;
 	}
 
 	export 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;
+		readonly providedDropEditKinds?: readonly DocumentPasteEditKind[];
 
 		/**
 		 * List of {@link DataTransfer} mime types that the provider can handle.

package/vscode-dts/vscode.proposed.fileComments.d.ts

@@ -59,10 +59,8 @@ declare module 'vscode' {
 		 */
 		label?: string;
 
-		/**
-		 * The optional state of a comment thread, which may affect how the comment is displayed.
-		 */
-		state?: CommentThreadState;
+		// from the commentThreadRelevance proposal
+		state?: CommentThreadState | { resolved?: CommentThreadState; applicability?: CommentThreadApplicability };
 
 		/**
 		 * Dispose this comment thread.

package/vscode-dts/vscode.proposed.inlineCompletionsAdditions.d.ts

@@ -53,6 +53,24 @@ declare module 'vscode' {
 		 */
 		// eslint-disable-next-line local/vscode-dts-provider-naming
 		handleDidPartiallyAcceptCompletionItem?(completionItem: InlineCompletionItem, acceptedLength: number): void;
+
+		/**
+		 * Is called when an inline completion item was accepted partially.
+		 * @param info Additional info for the partial accepted trigger.
+		 */
+		// eslint-disable-next-line local/vscode-dts-provider-naming
+		handleDidPartiallyAcceptCompletionItem?(completionItem: InlineCompletionItem, info: PartialAcceptInfo): void;
+	}
+
+	export interface PartialAcceptInfo {
+		kind: PartialAcceptTriggerKind;
+	}
+
+	export enum PartialAcceptTriggerKind {
+		Unknown = 0,
+		Word = 1,
+		Line = 2,
+		Suggest = 3,
 	}
 
 	// When finalizing `commands`, make sure to add a corresponding constructor parameter.

package/vscode-dts/vscode.proposed.interactive.d.ts

@@ -110,23 +110,9 @@ declare module 'vscode' {
 		handleInteractiveEditorResponseFeedback?(session: S, response: R, kind: InteractiveEditorResponseFeedbackKind): void;
 	}
 
-	export interface InteractiveSessionParticipantInformation {
-		name: string;
-
-		/**
-		 * A full URI for the icon of the participant.
-		 */
-		icon?: Uri;
-	}
-
 	export interface InteractiveSession {
-		requester: InteractiveSessionParticipantInformation;
-		responder: InteractiveSessionParticipantInformation;
-		inputPlaceholder?: string;
 	}
 
-	export type InteractiveWelcomeMessageContent = string | MarkdownString | ChatFollowup[];
-
 	export interface InteractiveSessionProvider<S extends InteractiveSession = InteractiveSession> {
 		prepareSession(token: CancellationToken): ProviderResult<S>;
 	}
@@ -144,8 +130,6 @@ declare module 'vscode' {
 
 		export function registerInteractiveSessionProvider(id: string, provider: InteractiveSessionProvider): Disposable;
 
-		export function sendInteractiveRequestToProvider(providerId: string, message: InteractiveSessionDynamicRequest): void;
-
 		export function registerInteractiveEditorSessionProvider(provider: InteractiveEditorSessionProvider, metadata?: InteractiveEditorSessionProviderMetadata): Disposable;
 
 		export function transferChatSession(session: InteractiveSession, toWorkspace: Uri): void;

package/vscode-dts/vscode.proposed.languageModels.d.ts

@@ -8,20 +8,14 @@ declare module 'vscode' {
 	/**
 	 * Represents a language model response.
 	 *
-	 * @see {@link LanguageModelAccess.makeChatRequest}
+	 * @see {@link LanguageModelAccess.chatRequest}
 	 */
-	export interface LanguageModelResponse {
-
-		/**
-		 * The overall result of the request which represents failure or success
-		 * but. The concrete value is not specified and depends on the selected language model.
-		 *
-		 * *Note* that the actual response represented by the {@link LanguageModelResponse.stream `stream`}-property
-		 */
-		result: Thenable<unknown>;
+	export interface LanguageModelChatResponse {
 
 		/**
 		 * An async iterable that is a stream of text chunks forming the overall response.
+		 *
+		 * *Note* that this stream will error when during data receiving an error occurrs.
 		 */
 		stream: AsyncIterable<string>;
 	}
@@ -35,7 +29,7 @@ declare module 'vscode' {
 	 * *Note* that a language model may choose to add additional system messages to the ones
 	 * provided by extensions.
 	 */
-	export class LanguageModelSystemMessage {
+	export class LanguageModelChatSystemMessage {
 
 		/**
 		 * The content of this message.
@@ -53,7 +47,7 @@ declare module 'vscode' {
 	/**
 	 * A language model message that represents a user message.
 	 */
-	export class LanguageModelUserMessage {
+	export class LanguageModelChatUserMessage {
 
 		/**
 		 * The content of this message.
@@ -78,78 +72,100 @@ declare module 'vscode' {
 	 * A language model message that represents an assistant message, usually in response to a user message
 	 * or as a sample response/reply-pair.
 	 */
-	export class LanguageModelAssistantMessage {
+	export class LanguageModelChatAssistantMessage {
 
 		/**
 		 * The content of this message.
 		 */
 		content: string;
 
+		/**
+		 * The optional name of a user for this message.
+		 */
+		name: string | undefined;
+
 		/**
 		 * Create a new assistant message.
 		 *
 		 * @param content The content of the message.
+		 * @param name The optional name of a user for the message.
 		 */
-		constructor(content: string);
+		constructor(content: string, name?: string);
 	}
 
-	export type LanguageModelMessage = LanguageModelSystemMessage | LanguageModelUserMessage | LanguageModelAssistantMessage;
-
 	/**
-	 * Represents access to using a language model. Access can be revoked at any time and extension
-	 * must check if the access is {@link LanguageModelAccess.isRevoked still valid} before using it.
+	 * Different types of language model messages.
 	 */
-	export interface LanguageModelAccess {
+	export type LanguageModelChatMessage = LanguageModelChatSystemMessage | LanguageModelChatUserMessage | LanguageModelChatAssistantMessage;
 
+	/**
+	 * An event describing the change in the set of available language models.
+	 */
+	export interface LanguageModelChangeEvent {
+		/**
+		 * Added language models.
+		 */
+		readonly added: readonly string[];
 		/**
-		 * Whether the access to the language model has been revoked.
+		 * Removed language models.
 		 */
-		readonly isRevoked: boolean;
+		readonly removed: readonly string[];
+	}
+
+	/**
+	 * An error type for language model specific errors.
+	 *
+	 * Consumers of language models should check the code property to determine specific
+	 * failure causes, like `if(someError.code === vscode.LanguageModelError.NotFound.name) {...}`
+	 * for the case of referring to an unknown language model. For unspecified errors the `cause`-property
+	 * will contain the actual error.
+	 */
+	export class LanguageModelError extends Error {
 
 		/**
-		 * An event that is fired when the access the language model has has been revoked or re-granted.
+		 * The language model does not exist.
 		 */
-		// TODO@API NAME?
-		readonly onDidChangeAccess: Event<void>;
+		static NotFound(message?: string): LanguageModelError;
 
 		/**
-		 * The name of the model.
-		 *
-		 * It is expected that the model name can be used to lookup properties like token limits or what
-		 * `options` are available.
+		 * The requestor does not have permissions to use this
+		 * language model
 		 */
-		readonly model: string;
+		static NoPermissions(message?: string): LanguageModelError;
 
 		/**
-		 * Make a request to the language model.
-		 *
-		 * *Note:* This will throw an error if access has been revoked.
+		 * A code that identifies this error.
 		 *
-		 * @param messages
-		 * @param options
+		 * Possible values are names of errors, like {@linkcode LanguageModelError.NotFound NotFound},
+		 * or `Unknown` for unspecified errors from the language model itself. In the latter case the
+		 * `cause`-property will contain the actual error.
 		 */
-		makeChatRequest(messages: LanguageModelMessage[], options: { [name: string]: any }, token: CancellationToken): LanguageModelResponse;
+		readonly code: string;
 	}
 
-	export interface LanguageModelAccessOptions {
+	/**
+	 * Options for making a chat request using a language model.
+	 *
+	 * @see {@link lm.chatRequest}
+	 */
+	export interface LanguageModelChatRequestOptions {
+
 		/**
 		 * A human-readable message that explains why access to a language model is needed and what feature is enabled by it.
 		 */
 		justification?: string;
-	}
 
-	/**
-	 * An event describing the change in the set of available language models.
-	 */
-	export interface LanguageModelChangeEvent {
 		/**
-		 * Added language models.
+		 * Do not show the consent UI if the user has not yet granted access to the language model but fail the request instead.
 		 */
-		readonly added: readonly string[];
+		// TODO@API Revisit this, how do you do the first request?
+		silent?: boolean;
+
 		/**
-		 * Removed language models.
+		 * A set of options that control the behavior of the language model. These options are specific to the language model
+		 * and need to be lookup in the respective documentation.
 		 */
-		readonly removed: readonly string[];
+		modelOptions?: { [name: string]: any };
 	}
 
 	/**
@@ -158,18 +174,28 @@ declare module 'vscode' {
 	export namespace lm {
 
 		/**
-		 * Request access to a language model.
+		 * Make a chat request using a language model.
+		 *
+		 * - *Note 1:* language model use may be subject to access restrictions and user consent.
 		 *
-		 * - *Note 1:* This function will throw an error when the user didn't grant access or when the
-		 * requested language model is not available.
+		 * - *Note 2:* language models are contributed by other extensions and as they evolve and change,
+		 * the set of available language models may change over time. Therefore it is strongly recommend to check
+		 * {@link languageModels} for aviailable values and handle missing language models gracefully.
 		 *
-		 * - *Note 2:* It is OK to hold on to the returned access object and use it later, but extensions
-		 * should check {@link LanguageModelAccess.isRevoked} before using it.
+		 * This function will return a rejected promise if making a request to the language model is not
+		 * possible. Reasons for this can be:
 		 *
-		 * @param id The id of the language model, see {@link languageModels} for valid values.
-		 * @returns A thenable that resolves to a language model access object, rejects if access wasn't granted
+		 * - user consent not given, see {@link LanguageModelError.NoPermissions `NoPermissions`}
+		 * - model does not exist, see {@link LanguageModelError.NotFound `NotFound`}
+		 * - quota limits exceeded, see {@link LanguageModelError.cause `LanguageModelError.cause`}
+		 *
+		 * @param languageModel A language model identifier.
+		 * @param messages An array of message instances.
+		 * @param options Options that control the request.
+		 * @param token A cancellation token which controls the request. See {@link CancellationTokenSource} for how to create one.
+		 * @returns A thenable that resolves to a {@link LanguageModelChatResponse}. The promise will reject when the request couldn't be made.
 		 */
-		export function requestLanguageModelAccess(id: string, options?: LanguageModelAccessOptions): Thenable<LanguageModelAccess>;
+		export function sendChatRequest(languageModel: string, messages: LanguageModelChatMessage[], options: LanguageModelChatRequestOptions, token: CancellationToken): Thenable<LanguageModelChatResponse>;
 
 		/**
 		 * The identifiers of all language models that are currently available.
@@ -181,4 +207,40 @@ declare module 'vscode' {
 		 */
 		export const onDidChangeLanguageModels: Event<LanguageModelChangeEvent>;
 	}
+
+	/**
+	 * Represents extension specific information about the access to language models.
+	 */
+	export interface LanguageModelAccessInformation {
+
+		/**
+		 * An event that fires when access information changes.
+		 */
+		onDidChange: Event<void>;
+
+		/**
+		 * Checks if a request can be made to a language model.
+		 *
+		 * *Note* that calling this function will not trigger a consent UI but just checks.
+		 *
+		 * @param languageModelId A language model identifier.
+		 * @return `true` if a request can be made, `false` if not, `undefined` if the language
+		 * model does not exist or consent hasn't been asked for.
+		 */
+		canSendRequest(languageModelId: string): boolean | undefined;
+
+		// TODO@API SYNC or ASYNC?
+		// TODO@API future
+		// retrieveQuota(languageModelId: string): { remaining: number; resets: Date };
+	}
+
+	export interface ExtensionContext {
+
+		/**
+		 * An object that keeps information about how this extension can use language models.
+		 *
+		 * @see {@link lm.sendChatRequest}
+		 */
+		readonly languageModelAccessInformation: LanguageModelAccessInformation;
+	}
 }

package/vscode-dts/vscode.proposed.notebookCellExecution.d.ts

@@ -0,0 +1,44 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+declare module 'vscode' {
+
+	export interface NotebookCellExecution {
+		/**
+		 * Signal that execution has ended.
+		 *
+		 * @param success If true, a green check is shown on the cell status bar.
+		 * If false, a red X is shown.
+		 * If undefined, no check or X icon is shown.
+		 * @param endTime The time that execution finished, in milliseconds in the Unix epoch.
+		 * @param error Details about an error that occurred during execution if any.
+		 */
+		end(success: boolean | undefined, endTime?: number, error?: CellExecutionError): void;
+	}
+
+	export interface CellExecutionError {
+		/**
+		 * The error message.
+		 */
+		readonly message: string;
+
+		/**
+		 * The error stack trace.
+		 */
+		readonly stack: string | undefined;
+
+		/**
+		 * The cell resource which had the error.
+		 */
+		uri: Uri;
+
+		/**
+		 * The location within the resource where the error occurred.
+		 */
+		readonly location: Range | undefined;
+
+
+	}
+}

package/vscode-dts/vscode.proposed.notebookVariableProvider.d.ts

@@ -45,6 +45,9 @@ declare module 'vscode' {
 		/** The type of the variable's value */
 		type?: string;
 
+		/** The interfaces or contracts that the type satisfies */
+		interfaces?: string[];
+
 		/** The language of the variable's value */
 		language?: string;
 	}

package/vscode-dts/vscode.proposed.tabInputMultiDiff.d.ts

@@ -0,0 +1,22 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+// https://github.com/microsoft/vscode/issues/206411
+
+declare module 'vscode' {
+
+	export class TabInputTextMultiDiff {
+
+		readonly textDiffs: TabInputTextDiff[];
+
+		constructor(textDiffs: TabInputTextDiff[]);
+	}
+
+	export interface Tab {
+
+		readonly input: TabInputText | TabInputTextDiff | TabInputTextMultiDiff | TabInputCustom | TabInputWebview | TabInputNotebook | TabInputNotebookDiff | TabInputTerminal | unknown;
+
+	}
+}