@theia/plugin-ext 1.38.0-next.7 → 1.38.0

package/src/plugin/env.ts

@@ -14,7 +14,6 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { Emitter, Event } from '@theia/core/lib/common/event';
 import * as theia from '@theia/plugin';
 import { RPCProtocol } from '../common/rpc-protocol';
 import { EnvMain, PLUGIN_RPC_CONTEXT } from '../common/plugin-api-rpc';
@@ -31,16 +30,12 @@ export abstract class EnvExtImpl {
     private envMachineId: string;
     private envSessionId: string;
     private host: string;
-    private _isTelemetryEnabled: boolean;
     private _remoteName: string | undefined;
-    private onDidChangeTelemetryEnabledEmitter = new Emitter<boolean>();
 
     constructor(rpc: RPCProtocol) {
         this.proxy = rpc.getProxy(PLUGIN_RPC_CONTEXT.ENV_MAIN);
         this.envSessionId = v4();
         this.envMachineId = v4();
-        // we don't support telemetry at the moment
-        this._isTelemetryEnabled = false;
         this._remoteName = undefined;
     }
 
@@ -101,14 +96,6 @@ export abstract class EnvExtImpl {
         return this.host;
     }
 
-    get isTelemetryEnabled(): boolean {
-        return this._isTelemetryEnabled;
-    }
-
-    get onDidChangeTelemetryEnabled(): Event<boolean> {
-        return this.onDidChangeTelemetryEnabledEmitter.event;
-    }
-
     get remoteName(): string | undefined {
         return this._remoteName;
     }

package/src/plugin/languages.ts

@@ -999,6 +999,16 @@ export class LanguagesExtImpl implements LanguagesExt {
         return result;
     }
     // #endregion
+
+    // region DocumentPaste
+
+    /** @stubbed */
+    registerDocumentPasteEditProvider(
+        extension: Plugin, selector: theia.DocumentSelector, provider: theia.DocumentPasteEditProvider, metadata: theia.DocumentPasteProviderMetadata
+    ): theia.Disposable {
+        return Disposable.NULL;
+    }
+    // #endregion
 }
 
 function getPluginLabel(pluginInfo: PluginInfo): string {

package/src/plugin/plugin-context.ts

@@ -160,9 +160,11 @@ import {
     TerminalLocation,
     TerminalExitReason,
     TerminalProfile,
+    TerminalQuickFixType,
     InlayHint,
     InlayHintKind,
     InlayHintLabelPart,
+    TelemetryTrustedValue,
     NotebookCell,
     NotebookCellKind,
     NotebookCellStatusBarAlignment,
@@ -191,7 +193,10 @@ import {
     TerminalEditorTabInput,
     TextDiffTabInput,
     TextMergeTabInput,
-    WebviewEditorTabInput
+    WebviewEditorTabInput,
+    DocumentPasteEdit,
+    ExternalUriOpenerPriority,
+    EditSessionIdentityMatch
 } from './types-impl';
 import { AuthenticationExtImpl } from './authentication-ext';
 import { SymbolKind } from '../common/plugin-api-rpc-model';
@@ -236,6 +241,7 @@ import { Endpoint } from '@theia/core/lib/browser/endpoint';
 import { FilePermission } from '@theia/filesystem/lib/common/files';
 import { TabsExtImpl } from './tabs';
 import { LocalizationExtImpl } from './localization-ext';
+import { TelemetryExtImpl } from './telemetry-ext';
 
 export function createAPIFactory(
     rpc: RPCProtocol,
@@ -277,6 +283,7 @@ export function createAPIFactory(
     const tabsExt = rpc.set(MAIN_RPC_CONTEXT.TABS_EXT, new TabsExtImpl(rpc));
     const customEditorExt = rpc.set(MAIN_RPC_CONTEXT.CUSTOM_EDITORS_EXT, new CustomEditorsExtImpl(rpc, documents, webviewExt, workspaceExt));
     const webviewViewsExt = rpc.set(MAIN_RPC_CONTEXT.WEBVIEW_VIEWS_EXT, new WebviewViewsExtImpl(rpc, webviewExt));
+    const telemetryExt = rpc.set(MAIN_RPC_CONTEXT.TELEMETRY_EXT, new TelemetryExtImpl());
     rpc.set(MAIN_RPC_CONTEXT.DEBUG_EXT, debugExt);
 
     return function (plugin: InternalPlugin): typeof theia {
@@ -569,6 +576,18 @@ export function createAPIFactory(
             },
             get tabGroups(): theia.TabGroups {
                 return tabsExt.tabGroups;
+            },
+            /** @stubbed ExternalUriOpener */
+            registerExternalUriOpener(id: string, opener: theia.ExternalUriOpener, metadata: theia.ExternalUriOpenerMetadata): theia.Disposable {
+                return Disposable.NULL;
+            },
+            /** @stubbed ProfileContentHandler */
+            registerProfileContentHandler(id: string, profileContentHandler: theia.ProfileContentHandler): theia.Disposable {
+                return Disposable.NULL;
+            },
+            /** @stubbed TerminalQuickFixProvider */
+            registerTerminalQuickFixProvider(id: string, provider: theia.TerminalQuickFixProvider): theia.Disposable {
+                return terminalExt.registerTerminalQuickFixProvider(id, provider);
             }
         };
 
@@ -714,7 +733,16 @@ export function createAPIFactory(
             },
             get onDidGrantWorkspaceTrust(): theia.Event<void> {
                 return workspaceExt.onDidGrantWorkspaceTrust;
-            }
+            },
+            registerEditSessionIdentityProvider(scheme: string, provider: theia.EditSessionIdentityProvider) {
+                return workspaceExt.$registerEditSessionIdentityProvider(scheme, provider);
+            },
+            /**
+             * @stubbed
+             * This is a stub implementation, that should minimally satisfy vscode built-in extensions
+             * that currently use this proposed API.
+             */
+            onWillCreateEditSessionIdentity: () => Disposable.NULL,
         };
 
         const onDidChangeLogLevel = new Emitter<theia.LogLevel>();
@@ -724,9 +752,12 @@ export function createAPIFactory(
             get appHost(): string { return envExt.appHost; },
             get language(): string { return envExt.language; },
             get isNewAppInstall(): boolean { return envExt.isNewAppInstall; },
-            get isTelemetryEnabled(): boolean { return envExt.isTelemetryEnabled; },
+            get isTelemetryEnabled(): boolean { return telemetryExt.isTelemetryEnabled; },
             get onDidChangeTelemetryEnabled(): theia.Event<boolean> {
-                return envExt.onDidChangeTelemetryEnabled;
+                return telemetryExt.onDidChangeTelemetryEnabled;
+            },
+            createTelemetryLogger(sender: theia.TelemetrySender, options?: theia.TelemetryLoggerOptions): theia.TelemetryLogger {
+                return telemetryExt.createTelemetryLogger(sender, options);
             },
             get remoteName(): string | undefined { return envExt.remoteName; },
             get machineId(): string { return envExt.machineId; },
@@ -918,6 +949,11 @@ export function createAPIFactory(
             },
             createLanguageStatusItem(id: string, selector: theia.DocumentSelector): theia.LanguageStatusItem {
                 return languagesExt.createLanguageStatusItem(plugin, id, selector);
+            },
+            registerDocumentPasteEditProvider(
+                selector: theia.DocumentSelector, provider: theia.DocumentPasteEditProvider, metadata: theia.DocumentPasteProviderMetadata
+            ): theia.Disposable {
+                return languagesExt.registerDocumentPasteEditProvider(plugin, selector, provider, metadata);
             }
         };
 
@@ -1307,6 +1343,7 @@ export function createAPIFactory(
             InlayHint,
             InlayHintKind,
             InlayHintLabelPart,
+            TelemetryTrustedValue,
             NotebookCellData,
             NotebookCellKind,
             NotebookCellOutput,
@@ -1336,7 +1373,11 @@ export function createAPIFactory(
             TabInputWebview: WebviewEditorTabInput,
             TabInputTerminal: TerminalEditorTabInput,
             TerminalLocation,
-            TerminalExitReason
+            TerminalExitReason,
+            DocumentPasteEdit,
+            ExternalUriOpenerPriority,
+            TerminalQuickFixType,
+            EditSessionIdentityMatch
         };
     };
 }

package/src/plugin/telemetry-ext.ts

@@ -0,0 +1,298 @@
+// *****************************************************************************
+// Copyright (C) 2023 STMicroelectronics and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+
+import { Event, Emitter } from '@theia/core/lib/common/event';
+import { cloneAndChange } from '@theia/core';
+import { mixin } from '../common/types';
+import { TelemetryTrustedValue, TelemetryLoggerOptions } from './types-impl';
+
+export class TelemetryExtImpl {
+
+    _isTelemetryEnabled: boolean = false; // telemetry not activated by default
+    private readonly onDidChangeTelemetryEnabledEmitter = new Emitter<boolean>();
+    readonly onDidChangeTelemetryEnabled: Event<boolean> = this.onDidChangeTelemetryEnabledEmitter.event;
+
+    get isTelemetryEnabled(): boolean {
+        return this._isTelemetryEnabled;
+    }
+
+    set isTelemetryEnabled(isTelemetryEnabled: boolean) {
+        if (this._isTelemetryEnabled !== isTelemetryEnabled) {
+            this._isTelemetryEnabled = isTelemetryEnabled;
+            this.onDidChangeTelemetryEnabledEmitter.fire(this._isTelemetryEnabled);
+        }
+    }
+
+    createTelemetryLogger(sender: TelemetrySender, options?: TelemetryLoggerOptions | undefined): TelemetryLogger {
+        const logger = new TelemetryLogger(sender, this._isTelemetryEnabled, options);
+        this.onDidChangeTelemetryEnabled(isEnabled => {
+            logger.telemetryEnabled = isEnabled;
+        });
+        return logger;
+    }
+}
+
+export class TelemetryLogger {
+    private sender: TelemetrySender | undefined;
+    readonly options: TelemetryLoggerOptions | undefined;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    readonly commonProperties: Record<string, any>;
+    telemetryEnabled: boolean;
+
+    private readonly onDidChangeEnableStatesEmitter: Emitter<TelemetryLogger> = new Emitter();
+    readonly onDidChangeEnableStates: Event<TelemetryLogger> = this.onDidChangeEnableStatesEmitter.event;
+    private _isUsageEnabled: boolean;
+    private _isErrorsEnabled: boolean;
+
+    constructor(sender: TelemetrySender, telemetryEnabled: boolean, options?: TelemetryLoggerOptions) {
+        this.sender = sender;
+        this.options = options;
+        this.commonProperties = this.getCommonProperties();
+        this._isErrorsEnabled = true;
+        this._isUsageEnabled = true;
+        this.telemetryEnabled = telemetryEnabled;
+    }
+
+    get isUsageEnabled(): boolean {
+        return this._isUsageEnabled;
+    }
+
+    set isUsageEnabled(isUsageEnabled: boolean) {
+        if (this._isUsageEnabled !== isUsageEnabled) {
+            this._isUsageEnabled = isUsageEnabled;
+            this.onDidChangeEnableStatesEmitter.fire(this);
+        }
+    }
+
+    get isErrorsEnabled(): boolean {
+        return this._isErrorsEnabled;
+    }
+
+    set isErrorsEnabled(isErrorsEnabled: boolean) {
+        if (this._isErrorsEnabled !== isErrorsEnabled) {
+            this._isErrorsEnabled = isErrorsEnabled;
+            this.onDidChangeEnableStatesEmitter.fire(this);
+        }
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    logUsage(eventName: string, data?: Record<string, any | TelemetryTrustedValue<any>>): void {
+        if (!this.telemetryEnabled || !this.isUsageEnabled) {
+            return;
+        }
+        this.logEvent(eventName, data);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    logError(eventNameOrException: string | Error, data?: Record<string, any | TelemetryTrustedValue<any>>): void {
+        if (!this.telemetryEnabled || !this.isErrorsEnabled || !this.sender) {
+            // no sender available or error shall not be sent
+            return;
+        }
+        if (typeof eventNameOrException === 'string') {
+            this.logEvent(eventNameOrException, data);
+        } else {
+            this.sender.sendErrorData(eventNameOrException, data);
+        }
+    }
+
+    dispose(): void {
+        if (this.sender?.flush) {
+            let tempSender: TelemetrySender | undefined = this.sender;
+            this.sender = undefined;
+            Promise.resolve(tempSender.flush!()).then(tempSender = undefined);
+        } else {
+            this.sender = undefined;
+        }
+    };
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    private logEvent(eventName: string, data?: Record<string, any>): void {
+        // No sender means likely disposed of, we should no-op
+        if (!this.sender) {
+            return;
+        }
+        data = mixInCommonPropsAndCleanData(data || {}, this.options?.additionalCommonProperties, this.options?.ignoreBuiltInCommonProperties ? undefined : this.commonProperties);
+        this.sender?.sendEventData(eventName, data);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    private getCommonProperties(): Record<string, any> {
+        return [];
+    }
+}
+
+interface TelemetrySender {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    sendEventData(eventName: string, data?: Record<string, any>): void;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    sendErrorData(error: Error, data?: Record<string, any>): void;
+    flush?(): void | Thenable<void>;
+}
+
+// copied and modified from https://github.com/microsoft/vscode/blob/1.76.0/src/vs/workbench/api/common/extHostTelemetry.ts
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function mixInCommonPropsAndCleanData(data: Record<string, any>, additionalProperties?: Record<string, any>, commonProperties?: Record<string, any>): Record<string, any> {
+    let updatedData = data.properties ?? data;
+
+    // We don't clean measurements since they are just numbers
+    updatedData = cleanData(updatedData, []);
+
+    if (additionalProperties) {
+        updatedData = mixin(updatedData, additionalProperties);
+    }
+
+    if (commonProperties) {
+        updatedData = mixin(updatedData, commonProperties);
+    }
+
+    if (data.properties) {
+        data.properties = updatedData;
+    } else {
+        data = updatedData;
+    }
+
+    return data;
+}
+
+// copied and modified from https://github.com/microsoft/vscode/blob/1.76.0/src/vs/platform/telemetry/common/telemetryUtils.ts#L321-L442
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+/**
+ * Cleans a given stack of possible paths
+ * @param stack The stack to sanitize
+ * @param cleanupPatterns Cleanup patterns to remove from the stack
+ * @returns The cleaned stack
+ */
+function anonymizeFilePaths(stack: string, cleanupPatterns: RegExp[]): string {
+
+    // Fast check to see if it is a file path to avoid doing unnecessary heavy regex work
+    if (!stack || (!stack.includes('/') && !stack.includes('\\'))) {
+        return stack;
+    }
+
+    let updatedStack = stack;
+
+    const cleanUpIndexes: [number, number][] = [];
+    for (const regexp of cleanupPatterns) {
+        while (true) {
+            const result = regexp.exec(stack);
+            if (!result) {
+                break;
+            }
+            cleanUpIndexes.push([result.index, regexp.lastIndex]);
+        }
+    }
+
+    const nodeModulesRegex = /^[\\\/]?(node_modules|node_modules\.asar)[\\\/]/;
+    const fileRegex = /(file:\/\/)?([a-zA-Z]:(\\\\|\\|\/)|(\\\\|\\|\/))?([\w-\._]+(\\\\|\\|\/))+[\w-\._]*/g;
+    let lastIndex = 0;
+    updatedStack = '';
+
+    while (true) {
+        const result = fileRegex.exec(stack);
+        if (!result) {
+            break;
+        }
+
+        // Check to see if the any cleanupIndexes partially overlap with this match
+        const overlappingRange = cleanUpIndexes.some(([start, end]) => result.index < end && start < fileRegex.lastIndex);
+
+        // anonymize user file paths that do not need to be retained or cleaned up.
+        if (!nodeModulesRegex.test(result[0]) && !overlappingRange) {
+            updatedStack += stack.substring(lastIndex, result.index) + '<REDACTED: user-file-path>';
+            lastIndex = fileRegex.lastIndex;
+        }
+    }
+    if (lastIndex < stack.length) {
+        updatedStack += stack.substring(lastIndex);
+    }
+
+    return updatedStack;
+}
+
+/**
+ * Attempts to remove commonly leaked PII
+ * @param property The property which will be removed if it contains user data
+ * @returns The new value for the property
+ */
+function removePropertiesWithPossibleUserInfo(property: string): string {
+    // If for some reason it is undefined we skip it (this shouldn't be possible);
+    if (!property) {
+        return property;
+    }
+
+    const value = property.toLowerCase();
+
+    const userDataRegexes = [
+        { label: 'Google API Key', regex: /AIza[0-9A-Za-z-_]{35}/ },
+        { label: 'Slack Token', regex: /xox[pbar]\-[A-Za-z0-9]/ },
+        { label: 'Generic Secret', regex: /(key|token|sig|secret|signature|password|passwd|pwd|android:value)[^a-zA-Z0-9]/ },
+        { label: 'Email', regex: /@[a-zA-Z0-9-]+\.[a-zA-Z0-9-]+/ } // Regex which matches @*.site
+    ];
+
+    // Check for common user data in the telemetry events
+    for (const secretRegex of userDataRegexes) {
+        if (secretRegex.regex.test(value)) {
+            return `<REDACTED: ${secretRegex.label}>`;
+        }
+    }
+
+    return property;
+}
+
+/**
+ * Does a best possible effort to clean a data object from any possible PII.
+ * @param data The data object to clean
+ * @param paths Any additional patterns that should be removed from the data set
+ * @returns A new object with the PII removed
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function cleanData(data: Record<string, any>, cleanUpPatterns: RegExp[]): Record<string, any> {
+    return cloneAndChange(data, value => {
+
+        // If it's a trusted value it means it's okay to skip cleaning so we don't clean it
+        if (value instanceof TelemetryTrustedValue) {
+            return value.value;
+        }
+
+        // We only know how to clean strings
+        if (typeof value === 'string') {
+            let updatedProperty = value.replace(/%20/g, ' ');
+
+            // First we anonymize any possible file paths
+            updatedProperty = anonymizeFilePaths(updatedProperty, cleanUpPatterns);
+
+            // Then we do a simple regex replace with the defined patterns
+            for (const regexp of cleanUpPatterns) {
+                updatedProperty = updatedProperty.replace(regexp, '');
+            }
+
+            // Lastly, remove commonly leaked PII
+            updatedProperty = removePropertiesWithPossibleUserInfo(updatedProperty);
+
+            return updatedProperty;
+        }
+        return undefined;
+    }, new Set());
+}

package/src/plugin/terminal-ext.ts

@@ -246,6 +246,11 @@ export class TerminalServiceExtImpl implements TerminalServiceExt {
         });
     }
 
+    /** @stubbed */
+    registerTerminalQuickFixProvider(id: string, provider: theia.TerminalQuickFixProvider): theia.Disposable {
+        return Disposable.NULL;
+    }
+
     protected isExtensionTerminalOptions(options: theia.TerminalOptions | theia.ExtensionTerminalOptions): options is theia.ExtensionTerminalOptions {
         return 'pty' in options;
     }

package/src/plugin/tree/tree-views.ts

@@ -234,7 +234,7 @@ class TreeViewExtImpl<T> implements Disposable {
         // make copies of optionally provided MIME types:
         const dragMimeTypes = options.dragAndDropController?.dragMimeTypes?.slice();
         const dropMimeTypes = options.dragAndDropController?.dropMimeTypes?.slice();
-        proxy.$registerTreeDataProvider(treeViewId, { canSelectMany: options.canSelectMany, dragMimeTypes, dropMimeTypes });
+        proxy.$registerTreeDataProvider(treeViewId, { showCollapseAll: options.showCollapseAll, canSelectMany: options.canSelectMany, dragMimeTypes, dropMimeTypes });
         this.toDispose.push(Disposable.create(() => this.proxy.$unregisterTreeDataProvider(treeViewId)));
         options.treeDataProvider.onDidChangeTreeData?.(() => {
             this.pendingRefresh = proxy.$refresh(treeViewId);
@@ -247,11 +247,14 @@ class TreeViewExtImpl<T> implements Disposable {
 
     async reveal(element: T, options?: Partial<TreeViewRevealOptions>): Promise<void> {
         await this.pendingRefresh;
+        const select = options?.select !== false; // default to true
+        const focus = !!options?.focus;
+        const expand = typeof options?.expand === 'undefined' ? false : options!.expand;
 
         const elementParentChain = await this.calculateRevealParentChain(element);
         if (elementParentChain) {
             return this.proxy.$reveal(this.treeViewId, elementParentChain, {
-                select: true, focus: false, expand: false, ...options
+                select, focus, expand, ...options
             });
         }
     }
@@ -308,37 +311,16 @@ class TreeViewExtImpl<T> implements Disposable {
      *
      * @param element element to reveal
      */
-    private async calculateRevealParentChain(element: T | undefined): Promise<string[] | undefined> {
+    private async calculateRevealParentChain(element: T | undefined): Promise<string[]> {
         if (!element) {
             // root
             return [];
         }
         const parent = await this.options.treeDataProvider.getParent?.(element) ?? undefined;
         const chain = await this.calculateRevealParentChain(parent);
-        if (!chain) {
-            // parents are inconsistent
-            return undefined;
-        }
         const parentId = chain.length ? chain[chain.length - 1] : '';
         const treeItem = await this.options.treeDataProvider.getTreeItem(element);
-        if (treeItem.id) {
-            return chain.concat(treeItem.id);
-        }
-        const cachedParentNode = this.nodes.get(parentId);
-        // first try to get children length from cache since getChildren disposes old nodes, which can cause a race
-        // condition if command is executed together with reveal.
-        // If not in cache, getChildren fills this.nodes and generate ids for them which are needed later
-        const children = cachedParentNode?.children || await this.getChildren(parentId);
-        if (!children) {
-            // parent is inconsistent
-            return undefined;
-        }
-        const candidateId = this.buildTreeItemId(parentId, treeItem, false);
-        if (this.nodes.has(candidateId)) {
-            return chain.concat(candidateId);
-        }
-        // couldn't calculate consistent parent chain and id
-        return undefined;
+        return chain.concat(this.buildTreeItemId(parentId, treeItem, false));
     }
 
     private getTreeItemLabel(treeItem: TreeItem): string | undefined {

package/src/plugin/types-impl.ts

@@ -229,6 +229,13 @@ export enum SourceControlInputBoxValidationType {
     Information = 2
 }
 
+export enum ExternalUriOpenerPriority {
+    None = 0,
+    Option = 1,
+    Default = 2,
+    Preferred = 3,
+}
+
 @es5ClassCompat
 export class ColorTheme implements theia.ColorTheme {
     constructor(public readonly kind: ColorThemeKind) { }
@@ -2059,6 +2066,11 @@ export enum TerminalExitReason {
     Extension = 4,
 }
 
+export enum TerminalQuickFixType {
+    command = 'command',
+    opener = 'opener'
+}
+
 @es5ClassCompat
 export class FileDecoration {
 
@@ -3413,6 +3425,54 @@ export class WebviewEditorTabInput {
     constructor(readonly viewType: string) { }
 }
 
+export class TelemetryTrustedValue<T> {
+    readonly value: T;
+
+    constructor(value: T) {
+        this.value = value;
+    }
+}
+
+export class TelemetryLogger {
+    readonly onDidChangeEnableStates: theia.Event<TelemetryLogger>;
+    readonly isUsageEnabled: boolean;
+    readonly isErrorsEnabled: boolean;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    logUsage(eventName: string, data?: Record<string, any | TelemetryTrustedValue<any>>): void { }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    logError(eventNameOrError: string | Error, data?: Record<string, any | TelemetryTrustedValue<any>>): void { }
+    dispose(): void { }
+    constructor(readonly sender: TelemetrySender, readonly options?: TelemetryLoggerOptions) { }
+}
+
+export interface TelemetrySender {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    sendEventData(eventName: string, data?: Record<string, any>): void;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    sendErrorData(error: Error, data?: Record<string, any>): void;
+    flush?(): void | Thenable<void>;
+}
+
+export interface TelemetryLoggerOptions {
+    /**
+     * Whether or not you want to avoid having the built-in common properties such as os, extension name, etc injected into the data object.
+     * Defaults to `false` if not defined.
+     */
+    readonly ignoreBuiltInCommonProperties?: boolean;
+
+    /**
+     * Whether or not unhandled errors on the extension host caused by your extension should be logged to your sender.
+     * Defaults to `false` if not defined.
+     */
+    readonly ignoreUnhandledErrors?: boolean;
+
+    /**
+     * Any additional common properties which should be injected into the data object.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    readonly additionalCommonProperties?: Record<string, any>;
+}
+
 export class NotebookEditorTabInput {
     constructor(readonly uri: URI, readonly notebookType: string) { }
 }
@@ -3429,3 +3489,22 @@ export class InteractiveWindowInput {
 }
 
 // #endregion
+
+// #region DocumentPaste
+@es5ClassCompat
+export class DocumentPasteEdit {
+    constructor(insertText: string | SnippetString) {
+        this.insertText = insertText;
+    }
+    insertText: string | SnippetString;
+    additionalEdit?: WorkspaceEdit;
+}
+// #endregion
+
+// #region DocumentPaste
+export enum EditSessionIdentityMatch {
+    Complete = 100,
+    Partial = 50,
+    None = 0
+}
+// #endregion

package/src/plugin/workspace.ts

@@ -34,7 +34,7 @@ import { Path } from '@theia/core/lib/common/path';
 import { RPCProtocol } from '../common/rpc-protocol';
 import { WorkspaceRootsChangeEvent, SearchInWorkspaceResult, Range } from '../common/plugin-api-rpc-model';
 import { EditorsAndDocumentsExtImpl } from './editors-and-documents';
-import { URI } from './types-impl';
+import { Disposable, URI } from './types-impl';
 import { normalize } from '@theia/core/lib/common/paths';
 import { relative } from '../common/paths-util';
 import { Schemes } from '../common/uri-components';
@@ -449,4 +449,9 @@ export class WorkspaceExtImpl implements WorkspaceExt {
         }
     }
 
+    /** @stubbed */
+    $registerEditSessionIdentityProvider(scheme: string, provider: theia.EditSessionIdentityProvider): theia.Disposable {
+        return Disposable.NULL;
+    }
+
 }