@codingame/monaco-vscode-extensions-service-override 11.1.2 → 12.0.1

package/vscode/src/vs/workbench/api/browser/mainThreadCustomEditors.js

@@ -1,4 +1,5 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { multibyteAwareBtoa } from 'vscode/vscode/vs/base/browser/dom';
 import { createCancelablePromise } from 'vscode/vscode/vs/base/common/async';
 import { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
@@ -12,30 +13,37 @@ import { URI } from 'vscode/vscode/vs/base/common/uri';
 import { generateUuid } from 'vscode/vscode/vs/base/common/uuid';
 import { localize } from 'vscode/vscode/vs/nls';
 import { IFileDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs.service';
+import { FileOperation } from 'vscode/vscode/vs/platform/files/common/files';
 import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 import { ILabelService } from 'vscode/vscode/vs/platform/label/common/label.service';
 import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
+import { UndoRedoElementType } from 'vscode/vscode/vs/platform/undoRedo/common/undoRedo';
 import { IUndoRedoService } from 'vscode/vscode/vs/platform/undoRedo/common/undoRedo.service';
 import { reviveWebviewExtension } from './mainThreadWebviews.js';
 import { ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
-import { CustomEditorInput } from 'vscode/vscode/vs/workbench/contrib/customEditor/browser/customEditorInput';
+import { CustomEditorInput } from '@codingame/monaco-vscode-7f39b6f1-3542-5430-8760-0f404d7a7cee-common/vscode/vs/workbench/contrib/customEditor/browser/customEditorInput';
 import { ICustomEditorService } from 'vscode/vscode/vs/workbench/contrib/customEditor/common/customEditor.service';
 import { CustomTextEditorModel } from '../../contrib/customEditor/common/customTextEditorModel.js';
-import { ExtensionKeyedWebviewOriginStore } from 'vscode/vscode/vs/workbench/contrib/webview/browser/webview';
+import { ExtensionKeyedWebviewOriginStore } from '@codingame/monaco-vscode-22790577-4553-50b6-978d-0acc75c394cc-common/vscode/vs/workbench/contrib/webview/browser/webview';
 import { IWebviewWorkbenchService } from 'vscode/vscode/vs/workbench/contrib/webviewPanel/browser/webviewWorkbenchService.service';
-import { editorGroupToColumn } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupColumn';
+import { editorGroupToColumn } from '@codingame/monaco-vscode-f48982c4-9e82-55e2-b800-20e6d1e6096f-common/vscode/vs/workbench/services/editor/common/editorGroupColumn';
 import { IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
 import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
 import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService.service';
 import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions.service';
 import { IPathService } from 'vscode/vscode/vs/workbench/services/path/common/pathService.service';
-import { ResourceWorkingCopy } from 'vscode/vscode/vs/workbench/services/workingCopy/common/resourceWorkingCopy';
-import { NO_TYPE_ID } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopy';
+import { ResourceWorkingCopy } from '@codingame/monaco-vscode-99f24462-c56d-5407-83fb-2ea9dd33cc8c-common/vscode/vs/workbench/services/workingCopy/common/resourceWorkingCopy';
+import { NO_TYPE_ID, WorkingCopyCapabilities } from '@codingame/monaco-vscode-a4683c2b-a0d2-5112-96ba-eedc605346d2-common/vscode/vs/workbench/services/workingCopy/common/workingCopy';
 import { IWorkingCopyFileService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService.service';
 import { IWorkingCopyService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyService.service';
 
 var MainThreadCustomEditorModel_1;
+var CustomEditorModelType;
+(function (CustomEditorModelType) {
+    CustomEditorModelType[CustomEditorModelType["Custom"] = 0] = "Custom";
+    CustomEditorModelType[CustomEditorModelType["Text"] = 1] = "Text";
+})(CustomEditorModelType || (CustomEditorModelType = {}));
 let MainThreadCustomEditors = class MainThreadCustomEditors extends Disposable {
     constructor(context, mainThreadWebview, mainThreadWebviewPanels, extensionService, storageService, workingCopyService, workingCopyFileService, _customEditorService, _editorGroupService, _editorService, _instantiationService, _webviewWorkbenchService) {
         super();
@@ -46,10 +54,10 @@ let MainThreadCustomEditors = class MainThreadCustomEditors extends Disposable {
         this._editorService = _editorService;
         this._instantiationService = _instantiationService;
         this._webviewWorkbenchService = _webviewWorkbenchService;
-        this._editorProviders = this._register(( (new DisposableMap())));
-        this._editorRenameBackups = ( (new Map()));
-        this._webviewOriginStore = ( (new ExtensionKeyedWebviewOriginStore('mainThreadCustomEditors.origins', storageService)));
-        this._proxyCustomEditors = ( (context.getProxy(ExtHostContext.ExtHostCustomEditors)));
+        this._editorProviders = this._register(( new DisposableMap()));
+        this._editorRenameBackups = ( new Map());
+        this._webviewOriginStore = ( new ExtensionKeyedWebviewOriginStore('mainThreadCustomEditors.origins', storageService));
+        this._proxyCustomEditors = ( context.getProxy(ExtHostContext.ExtHostCustomEditors));
         this._register(workingCopyFileService.registerWorkingCopyProvider((editorResource) => {
             const matchedWorkingCopies = [];
             for (const workingCopy of workingCopyService.workingCopies) {
@@ -68,21 +76,21 @@ let MainThreadCustomEditors = class MainThreadCustomEditors extends Disposable {
                 }
                 return false;
             },
-            resolveWebview: () => { throw ( (new Error('not implemented'))); }
+            resolveWebview: () => { throw ( new Error('not implemented')); }
         }));
         this._register(workingCopyFileService.onWillRunWorkingCopyFileOperation(async (e) => this.onWillRunWorkingCopyFileOperation(e)));
     }
     $registerTextEditorProvider(extensionData, viewType, options, capabilities, serializeBuffersForPostMessage) {
-        this.registerEditorProvider(1 , reviveWebviewExtension(extensionData), viewType, options, capabilities, true, serializeBuffersForPostMessage);
+        this.registerEditorProvider(CustomEditorModelType.Text, reviveWebviewExtension(extensionData), viewType, options, capabilities, true, serializeBuffersForPostMessage);
     }
     $registerCustomEditorProvider(extensionData, viewType, options, supportsMultipleEditorsPerDocument, serializeBuffersForPostMessage) {
-        this.registerEditorProvider(0 , reviveWebviewExtension(extensionData), viewType, options, {}, supportsMultipleEditorsPerDocument, serializeBuffersForPostMessage);
+        this.registerEditorProvider(CustomEditorModelType.Custom, reviveWebviewExtension(extensionData), viewType, options, {}, supportsMultipleEditorsPerDocument, serializeBuffersForPostMessage);
     }
     registerEditorProvider(modelType, extension, viewType, options, capabilities, supportsMultipleEditorsPerDocument, serializeBuffersForPostMessage) {
-        if (( (this._editorProviders.has(viewType)))) {
-            throw ( (new Error(`Provider for ${viewType} already registered`)));
+        if (( this._editorProviders.has(viewType))) {
+            throw ( new Error(`Provider for ${viewType} already registered`));
         }
-        const disposables = ( (new DisposableStore()));
+        const disposables = ( new DisposableStore());
         disposables.add(this._customEditorService.registerCustomEditorCapabilities(viewType, {
             supportsMultipleEditorsPerDocument
         }));
@@ -99,9 +107,9 @@ let MainThreadCustomEditors = class MainThreadCustomEditors extends Disposable {
                 webviewInput.webview.extension = extension;
                 let backupId = webviewInput.backupId;
                 if (webviewInput.oldResource && !webviewInput.backupId) {
-                    const backup = this._editorRenameBackups.get(( (webviewInput.oldResource.toString())));
+                    const backup = this._editorRenameBackups.get(( webviewInput.oldResource.toString()));
                     backupId = backup?.backupId;
-                    this._editorRenameBackups.delete(( (webviewInput.oldResource.toString())));
+                    this._editorRenameBackups.delete(( webviewInput.oldResource.toString()));
                 }
                 let modelRef;
                 try {
@@ -155,8 +163,8 @@ let MainThreadCustomEditors = class MainThreadCustomEditors extends Disposable {
         this._editorProviders.set(viewType, disposables);
     }
     $unregisterEditorProvider(viewType) {
-        if (!( (this._editorProviders.has(viewType)))) {
-            throw ( (new Error(`No provider for ${viewType} registered`)));
+        if (!( this._editorProviders.has(viewType))) {
+            throw ( new Error(`No provider for ${viewType} registered`));
         }
         this._editorProviders.deleteAndDispose(viewType);
         this._customEditorService.models.disposeAllModelsForView(viewType);
@@ -167,12 +175,12 @@ let MainThreadCustomEditors = class MainThreadCustomEditors extends Disposable {
             return existingModel;
         }
         switch (modelType) {
-            case 1 :
+            case CustomEditorModelType.Text:
                 {
                     const model = CustomTextEditorModel.create(this._instantiationService, viewType, resource);
                     return this._customEditorService.models.add(resource, viewType, model);
                 }
-            case 0 :
+            case CustomEditorModelType.Custom:
                 {
                     const model = MainThreadCustomEditorModel.create(this._instantiationService, this._proxyCustomEditors, viewType, resource, options, () => {
                         return Array.from(this.mainThreadWebviewPanels.webviewInputs)
@@ -194,12 +202,12 @@ let MainThreadCustomEditors = class MainThreadCustomEditors extends Disposable {
         const resource = URI.revive(resourceComponents);
         const model = await this._customEditorService.models.get(resource, viewType);
         if (!model || !(model instanceof MainThreadCustomEditorModel)) {
-            throw ( (new Error('Could not find model for webview editor')));
+            throw ( new Error('Could not find model for webview editor'));
         }
         return model;
     }
     async onWillRunWorkingCopyFileOperation(e) {
-        if (e.operation !== 2 ) {
+        if (e.operation !== FileOperation.MOVE) {
             return;
         }
         e.waitUntil((async () => {
@@ -213,41 +221,42 @@ let MainThreadCustomEditors = class MainThreadCustomEditors extends Disposable {
                 if (model instanceof MainThreadCustomEditorModel && model.isDirty()) {
                     const workingCopy = await model.backup(CancellationToken.None);
                     if (workingCopy.meta) {
-                        this._editorRenameBackups.set(( (model.editorResource.toString())), workingCopy.meta);
+                        this._editorRenameBackups.set(( model.editorResource.toString()), workingCopy.meta);
                     }
                 }
             }
         })());
     }
 };
-MainThreadCustomEditors = ( (__decorate([
-    ( (__param(3, IExtensionService))),
-    ( (__param(4, IStorageService))),
-    ( (__param(5, IWorkingCopyService))),
-    ( (__param(6, IWorkingCopyFileService))),
-    ( (__param(7, ICustomEditorService))),
-    ( (__param(8, IEditorGroupsService))),
-    ( (__param(9, IEditorService))),
-    ( (__param(10, IInstantiationService))),
-    ( (__param(11, IWebviewWorkbenchService)))
-], MainThreadCustomEditors)));
+MainThreadCustomEditors = ( __decorate([
+    ( __param(3, IExtensionService)),
+    ( __param(4, IStorageService)),
+    ( __param(5, IWorkingCopyService)),
+    ( __param(6, IWorkingCopyFileService)),
+    ( __param(7, ICustomEditorService)),
+    ( __param(8, IEditorGroupsService)),
+    ( __param(9, IEditorService)),
+    ( __param(10, IInstantiationService)),
+    ( __param(11, IWebviewWorkbenchService))
+], MainThreadCustomEditors));
 var HotExitState;
-( ((function(HotExitState) {
-    ( ((function(Type) {
+(function (HotExitState) {
+    let Type;
+    (function (Type) {
         Type[Type["Allowed"] = 0] = "Allowed";
         Type[Type["NotAllowed"] = 1] = "NotAllowed";
         Type[Type["Pending"] = 2] = "Pending";
-    })(HotExitState.Type || (HotExitState.Type = {}))));
-    HotExitState.Allowed = ( (Object.freeze({ type: 0  })));
-    HotExitState.NotAllowed = ( (Object.freeze({ type: 1  })));
+    })(Type = HotExitState.Type || (HotExitState.Type = {}));
+    HotExitState.Allowed = ( Object.freeze({ type: Type.Allowed }));
+    HotExitState.NotAllowed = ( Object.freeze({ type: Type.NotAllowed }));
     class Pending {
         constructor(operation) {
             this.operation = operation;
-            this.type = 2 ;
+            this.type = Type.Pending;
         }
     }
     HotExitState.Pending = Pending;
-})(HotExitState || (HotExitState = {}))));
+})(HotExitState || (HotExitState = {}));
 let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThreadCustomEditorModel extends ResourceWorkingCopy {
     static async create(instantiationService, proxy, viewType, resource, options, getEditors, cancellation) {
         const editors = getEditors();
@@ -277,18 +286,18 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
         this._edits = [];
         this._isDirtyFromContentChange = false;
         this.typeId = NO_TYPE_ID;
-        this._onDidChangeDirty = this._register(( (new Emitter())));
+        this._onDidChangeDirty = this._register(( new Emitter()));
         this.onDidChangeDirty = this._onDidChangeDirty.event;
-        this._onDidChangeContent = this._register(( (new Emitter())));
+        this._onDidChangeContent = this._register(( new Emitter()));
         this.onDidChangeContent = this._onDidChangeContent.event;
-        this._onDidSave = this._register(( (new Emitter())));
+        this._onDidSave = this._register(( new Emitter()));
         this.onDidSave = this._onDidSave.event;
         this.onDidChangeReadonly = Event.None;
         this._fromBackup = fromBackup;
         if (_editable) {
             this._register(workingCopyService.registerWorkingCopy(this));
             this._register(extensionService.onWillStop(e => {
-                e.veto(true, ( localize(10029, "A custom editor for '{0}' is open.", this.name)));
+                e.veto(true, ( localize(2256, "A custom editor for '{0}' is open.", this.name)));
             }));
         }
         if (startDirty) {
@@ -307,21 +316,19 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
     }
     static toWorkingCopyResource(viewType, resource) {
         const authority = viewType.replace(/[^a-z0-9\-_]/gi, '-');
-        const path = `/${multibyteAwareBtoa(( (resource.with({ query: null, fragment: null }).toString(true))))}`;
-        return (
-             (URI.from({
-                scheme: Schemas.vscodeCustomEditor,
-                authority: authority,
-                path: path,
-                query: JSON.stringify(resource.toJSON()),
-            }))
-        );
+        const path = `/${multibyteAwareBtoa(( resource.with({ query: null, fragment: null }).toString(true)))}`;
+        return ( URI.from({
+            scheme: Schemas.vscodeCustomEditor,
+            authority: authority,
+            path: path,
+            query: JSON.stringify(resource.toJSON()),
+        }));
     }
     get name() {
         return basename(this._labelService.getUriLabel(this._editorResource));
     }
     get capabilities() {
-        return this.isUntitled() ? 2  : 0 ;
+        return this.isUntitled() ? WorkingCopyCapabilities.Untitled : WorkingCopyCapabilities.None;
     }
     isDirty() {
         if (this._isDirtyFromContentChange) {
@@ -346,16 +353,16 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
     }
     pushEdit(editId, label) {
         if (!this._editable) {
-            throw ( (new Error('Document is not editable')));
+            throw ( new Error('Document is not editable'));
         }
         this.change(() => {
             this.spliceEdits(editId);
             this._currentEditIndex = this._edits.length - 1;
         });
         this._undoService.pushElement({
-            type: 0 ,
+            type: UndoRedoElementType.Resource,
             resource: this._editorResource,
-            label: label ?? ( localize(10030, "Edit")),
+            label: label ?? ( localize(2257, "Edit")),
             code: 'undoredo.customEditorEdit',
             undo: () => this.undo(),
             redo: () => this.redo(),
@@ -468,7 +475,7 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
     }
     suggestUntitledSavePath(options) {
         if (!this.isUntitled()) {
-            throw ( (new Error('Resource is not untitled')));
+            throw ( new Error('Resource is not untitled'));
         }
         const remoteAuthority = this._environmentService.remoteAuthority;
         const localResource = toLocalResource(this._editorResource, remoteAuthority, this._pathService.defaultUriScheme);
@@ -487,11 +494,11 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
             return true;
         }
     }
-    get canHotExit() { return typeof this._backupId === 'string' && this._hotExitState.type === 0 ; }
+    get canHotExit() { return typeof this._backupId === 'string' && this._hotExitState.type === HotExitState.Type.Allowed; }
     async backup(token) {
         const editors = this._getEditors();
         if (!editors.length) {
-            throw ( (new Error('No editors found for resource, cannot back up')));
+            throw ( new Error('No editors found for resource, cannot back up'));
         }
         const primaryEditor = editors[0];
         const backupMeta = {
@@ -514,7 +521,7 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
         if (!this._editable) {
             return backupData;
         }
-        if (this._hotExitState.type === 2 ) {
+        if (this._hotExitState.type === HotExitState.Type.Pending) {
             this._hotExitState.operation.cancel();
         }
         const pendingState = new HotExitState.Pending(createCancelablePromise(token => this._proxy.$backup(this._editorResource.toJSON(), this.viewType, token)));
@@ -545,18 +552,18 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
         if (this._hotExitState === HotExitState.Allowed) {
             return backupData;
         }
-        throw ( (new Error(`Cannot backup in this state: ${errorMessage}`)));
+        throw ( new Error(`Cannot backup in this state: ${errorMessage}`));
     }
 };
-MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = ( (__decorate([
-    ( (__param(7, IFileDialogService))),
-    ( (__param(8, IFileService))),
-    ( (__param(9, ILabelService))),
-    ( (__param(10, IUndoRedoService))),
-    ( (__param(11, IWorkbenchEnvironmentService))),
-    ( (__param(12, IWorkingCopyService))),
-    ( (__param(13, IPathService))),
-    ( (__param(14, IExtensionService)))
-], MainThreadCustomEditorModel)));
+MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = ( __decorate([
+    ( __param(7, IFileDialogService)),
+    ( __param(8, IFileService)),
+    ( __param(9, ILabelService)),
+    ( __param(10, IUndoRedoService)),
+    ( __param(11, IWorkbenchEnvironmentService)),
+    ( __param(12, IWorkingCopyService)),
+    ( __param(13, IPathService)),
+    ( __param(14, IExtensionService))
+], MainThreadCustomEditorModel));
 
 export { MainThreadCustomEditors };

package/vscode/src/vs/workbench/api/browser/mainThreadDebugService.d.ts

@@ -0,0 +1,53 @@
+import { UriComponents } from "vscode/vscode/vs/base/common/uri";
+import { IConfig, IDebugAdapter, IDebugSession, IDebugAdapterFactory, DebugConfigurationProviderTriggerKind } from "vscode/vscode/vs/workbench/contrib/debug/common/debug";
+import { IDebugService } from "vscode/vscode/vs/workbench/contrib/debug/common/debug.service";
+import { MainThreadDebugServiceShape, DebugSessionUUID, ISourceMultiBreakpointDto, IFunctionBreakpointDto, IDebugSessionDto, IDataBreakpointDto, IStartDebuggingOptions, IDebugConfiguration } from "vscode/vscode/vs/workbench/api/common/extHost.protocol";
+import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
+import { IWorkspaceFolder } from "vscode/vscode/vs/platform/workspace/common/workspace";
+import { IDebugVisualizerService } from "vscode/vscode/vs/workbench/contrib/debug/common/debugVisualizers.service";
+export declare class MainThreadDebugService implements MainThreadDebugServiceShape, IDebugAdapterFactory {
+    private readonly debugService;
+    private readonly visualizerService;
+    private readonly _proxy;
+    private readonly _toDispose;
+    private readonly _debugAdapters;
+    private _debugAdaptersHandleCounter;
+    private readonly _debugConfigurationProviders;
+    private readonly _debugAdapterDescriptorFactories;
+    private readonly _extHostKnownSessions;
+    private readonly _visualizerHandles;
+    private readonly _visualizerTreeHandles;
+    constructor(extHostContext: IExtHostContext, debugService: IDebugService, visualizerService: IDebugVisualizerService);
+    $registerDebugVisualizerTree(treeId: string, canEdit: boolean): void;
+    $unregisterDebugVisualizerTree(treeId: string): void;
+    $registerDebugVisualizer(extensionId: string, id: string): void;
+    $unregisterDebugVisualizer(extensionId: string, id: string): void;
+    private sendBreakpointsAndListen;
+    dispose(): void;
+    createDebugAdapter(session: IDebugSession): IDebugAdapter;
+    substituteVariables(folder: IWorkspaceFolder | undefined, config: IConfig): Promise<IConfig>;
+    runInTerminal(args: DebugProtocol.RunInTerminalRequestArguments, sessionId: string): Promise<number | undefined>;
+    $registerDebugTypes(debugTypes: string[]): void;
+    $registerBreakpoints(DTOs: Array<ISourceMultiBreakpointDto | IFunctionBreakpointDto | IDataBreakpointDto>): Promise<void>;
+    $unregisterBreakpoints(breakpointIds: string[], functionBreakpointIds: string[], dataBreakpointIds: string[]): Promise<void>;
+    $registerDebugConfigurationProvider(debugType: string, providerTriggerKind: DebugConfigurationProviderTriggerKind, hasProvide: boolean, hasResolve: boolean, hasResolve2: boolean, handle: number): Promise<void>;
+    $unregisterDebugConfigurationProvider(handle: number): void;
+    $registerDebugAdapterDescriptorFactory(debugType: string, handle: number): Promise<void>;
+    $unregisterDebugAdapterDescriptorFactory(handle: number): void;
+    private getSession;
+    $startDebugging(folder: UriComponents | undefined, nameOrConfig: string | IDebugConfiguration, options: IStartDebuggingOptions): Promise<boolean>;
+    $setDebugSessionName(sessionId: DebugSessionUUID, name: string): void;
+    $customDebugAdapterRequest(sessionId: DebugSessionUUID, request: string, args: any): Promise<any>;
+    $getDebugProtocolBreakpoint(sessionId: DebugSessionUUID, breakpoinId: string): Promise<DebugProtocol.Breakpoint | undefined>;
+    $stopDebugging(sessionId: DebugSessionUUID | undefined): Promise<void>;
+    $appendDebugConsole(value: string): void;
+    $acceptDAMessage(handle: number, message: DebugProtocol.ProtocolMessage): void;
+    $acceptDAError(handle: number, name: string, message: string, stack: string): void;
+    $acceptDAExit(handle: number, code: number, signal: string): void;
+    private getDebugAdapter;
+    $sessionCached(sessionID: string): void;
+    getSessionDto(session: undefined): undefined;
+    getSessionDto(session: IDebugSession): IDebugSessionDto;
+    getSessionDto(session: IDebugSession | undefined): IDebugSessionDto | undefined;
+    private convertToDto;
+}

package/vscode/src/vs/workbench/api/browser/mainThreadDebugService.js

@@ -1,11 +1,12 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { DisposableStore, DisposableMap, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
-import { IDebugVisualization } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+import { IDebugVisualization, DataBreakpointSetType } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
 import { IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug.service';
 import { ExtHostContext, MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import Severity$1 from 'vscode/vscode/vs/base/common/severity';
+import Severity from 'vscode/vscode/vs/base/common/severity';
 import { AbstractDebugAdapter } from 'vscode/vscode/vs/workbench/contrib/debug/common/abstractDebugAdapter';
 import { isSessionAttach, convertToVSCPaths, convertToDAPaths } from 'vscode/vscode/vs/workbench/contrib/debug/common/debugUtils';
 import { ErrorNoTelemetry } from 'vscode/vscode/vs/base/common/errors';
@@ -190,7 +191,7 @@ let MainThreadDebugService = class MainThreadDebugService {
             else if (dto.type === 'data') {
                 this.debugService.addDataBreakpoint({
                     description: dto.label,
-                    src: { type: 0 , dataId: dto.dataId },
+                    src: { type: DataBreakpointSetType.Variable, dataId: dto.dataId },
                     canPersist: dto.canPersist,
                     accessTypes: dto.accessTypes,
                     accessType: dto.accessType,
@@ -325,7 +326,7 @@ let MainThreadDebugService = class MainThreadDebugService {
     }
     $appendDebugConsole(value) {
         const session = this.debugService.getViewModel().focusedSession;
-        session?.appendToRepl({ output: value, sev: Severity$1.Warning });
+        session?.appendToRepl({ output: value, sev: Severity.Warning });
     }
     $acceptDAMessage(handle, message) {
         this.getDebugAdapter(handle).acceptMessage(convertToVSCPaths(message, false));
@@ -384,7 +385,7 @@ let MainThreadDebugService = class MainThreadDebugService {
                 return {
                     type: 'data',
                     id: dbp.getId(),
-                    dataId: dbp.src.type === 0  ? dbp.src.dataId : dbp.src.address,
+                    dataId: dbp.src.type === DataBreakpointSetType.Variable ? dbp.src.dataId : dbp.src.address,
                     enabled: dbp.enabled,
                     condition: dbp.condition,
                     hitCondition: dbp.hitCondition,

package/vscode/src/vs/workbench/api/browser/mainThreadDecorations.d.ts

@@ -0,0 +1,14 @@
+import { UriComponents } from "vscode/vscode/vs/base/common/uri";
+import { MainThreadDecorationsShape } from "vscode/vscode/vs/workbench/api/common/extHost.protocol";
+import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
+import { IDecorationsService } from "vscode/vscode/vs/workbench/services/decorations/common/decorations.service";
+export declare class MainThreadDecorations implements MainThreadDecorationsShape {
+    private readonly _decorationsService;
+    private readonly _provider;
+    private readonly _proxy;
+    constructor(context: IExtHostContext, _decorationsService: IDecorationsService);
+    dispose(): void;
+    $registerDecorationProvider(handle: number, label: string): void;
+    $onDidChange(handle: number, resources: UriComponents[]): void;
+    $unregisterDecorationProvider(handle: number): void;
+}

package/vscode/src/vs/workbench/api/browser/mainThreadDecorations.js

@@ -1,4 +1,5 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
 import { Emitter } from 'vscode/vscode/vs/base/common/event';
 import { dispose } from 'vscode/vscode/vs/base/common/lifecycle';

package/vscode/src/vs/workbench/api/browser/mainThreadDiagnostics.d.ts

@@ -0,0 +1,21 @@
+import { IMarkerData } from "vscode/vscode/vs/platform/markers/common/markers";
+import { IMarkerService } from "vscode/vscode/vs/platform/markers/common/markers.service";
+import { UriComponents } from "vscode/vscode/vs/base/common/uri";
+import { MainThreadDiagnosticsShape } from "vscode/vscode/vs/workbench/api/common/extHost.protocol";
+import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
+import { IUriIdentityService } from "vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
+export declare class MainThreadDiagnostics implements MainThreadDiagnosticsShape {
+    private readonly _markerService;
+    private readonly _uriIdentService;
+    private readonly _activeOwners;
+    private readonly _proxy;
+    private readonly _markerListener;
+    constructor(extHostContext: IExtHostContext, _markerService: IMarkerService, _uriIdentService: IUriIdentityService);
+    dispose(): void;
+    private _forwardMarkers;
+    $changeMany(owner: string, entries: [
+        UriComponents,
+        IMarkerData[]
+    ][]): void;
+    $clear(owner: string): void;
+}

package/vscode/src/vs/workbench/api/browser/mainThreadDiagnostics.js

@@ -1,4 +1,5 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { IMarkerService } from 'vscode/vscode/vs/platform/markers/common/markers.service';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
 import { ExtHostContext, MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';

package/vscode/src/vs/workbench/api/browser/mainThreadDialogs.d.ts

@@ -0,0 +1,13 @@
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { MainThreadDiaglogsShape, MainThreadDialogOpenOptions, MainThreadDialogSaveOptions } from "vscode/vscode/vs/workbench/api/common/extHost.protocol";
+import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
+import { IFileDialogService } from "vscode/vscode/vs/platform/dialogs/common/dialogs.service";
+export declare class MainThreadDialogs implements MainThreadDiaglogsShape {
+    private readonly _fileDialogService;
+    constructor(context: IExtHostContext, _fileDialogService: IFileDialogService);
+    dispose(): void;
+    $showOpenDialog(options?: MainThreadDialogOpenOptions): Promise<URI[] | undefined>;
+    $showSaveDialog(options?: MainThreadDialogSaveOptions): Promise<URI | undefined>;
+    private static _convertOpenOptions;
+    private static _convertSaveOptions;
+}

package/vscode/src/vs/workbench/api/browser/mainThreadDialogs.js

@@ -1,4 +1,5 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
 import { MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';

package/vscode/src/vs/workbench/api/browser/mainThreadDocumentContentProviders.d.ts

@@ -0,0 +1,21 @@
+import { UriComponents } from "vscode/vscode/vs/base/common/uri";
+import { IEditorWorkerService } from "vscode/vscode/vs/editor/common/services/editorWorker";
+import { IModelService } from "vscode/vscode/vs/editor/common/services/model";
+import { ILanguageService } from "vscode/vscode/vs/editor/common/languages/language";
+import { ITextModelService } from "vscode/vscode/vs/editor/common/services/resolverService";
+import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
+import { MainThreadDocumentContentProvidersShape } from "vscode/vscode/vs/workbench/api/common/extHost.protocol";
+export declare class MainThreadDocumentContentProviders implements MainThreadDocumentContentProvidersShape {
+    private readonly _textModelResolverService;
+    private readonly _languageService;
+    private readonly _modelService;
+    private readonly _editorWorkerService;
+    private readonly _resourceContentProvider;
+    private readonly _pendingUpdate;
+    private readonly _proxy;
+    constructor(extHostContext: IExtHostContext, _textModelResolverService: ITextModelService, _languageService: ILanguageService, _modelService: IModelService, _editorWorkerService: IEditorWorkerService);
+    dispose(): void;
+    $registerTextContentProvider(handle: number, scheme: string): void;
+    $unregisterTextContentProvider(handle: number): void;
+    $onVirtualDocumentChange(uri: UriComponents, value: string): Promise<void>;
+}

package/vscode/src/vs/workbench/api/browser/mainThreadDocumentContentProviders.js

@@ -1,4 +1,5 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { onUnexpectedError } from 'vscode/vscode/vs/base/common/errors';
 import { DisposableMap, dispose } from 'vscode/vscode/vs/base/common/lifecycle';
 import { URI } from 'vscode/vscode/vs/base/common/uri';

package/vscode/src/vs/workbench/api/browser/mainThreadDocuments.d.ts

@@ -0,0 +1,58 @@
+import { IReference, Disposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { URI, UriComponents } from "vscode/vscode/vs/base/common/uri";
+import { ITextModel } from "vscode/vscode/vs/editor/common/model";
+import { IModelService } from "vscode/vscode/vs/editor/common/services/model";
+import { ITextModelService } from "vscode/vscode/vs/editor/common/services/resolverService";
+import { IFileService } from "vscode/vscode/vs/platform/files/common/files.service";
+import { MainThreadDocumentsShape } from "vscode/vscode/vs/workbench/api/common/extHost.protocol";
+import { ITextFileService } from "vscode/vscode/vs/workbench/services/textfile/common/textfiles.service";
+import { IWorkbenchEnvironmentService } from "vscode/vscode/vs/workbench/services/environment/common/environmentService.service";
+import { IExtUri } from "vscode/vscode/vs/base/common/resources";
+import { IWorkingCopyFileService } from "vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService.service";
+import { IUriIdentityService } from "vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
+import { Event } from "vscode/vscode/vs/base/common/event";
+import { IPathService } from "vscode/vscode/vs/workbench/services/path/common/pathService.service";
+import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
+export declare class BoundModelReferenceCollection {
+    private readonly _extUri;
+    private readonly _maxAge;
+    private readonly _maxLength;
+    private readonly _maxSize;
+    private _data;
+    private _length;
+    constructor(_extUri: IExtUri, _maxAge?: number, _maxLength?: number, _maxSize?: number);
+    dispose(): void;
+    remove(uri: URI): void;
+    add(uri: URI, ref: IReference<any>, length?: number): void;
+    private _cleanup;
+}
+export declare class MainThreadDocuments extends Disposable implements MainThreadDocumentsShape {
+    private readonly _modelService;
+    private readonly _textFileService;
+    private readonly _fileService;
+    private readonly _textModelResolverService;
+    private readonly _environmentService;
+    private readonly _uriIdentityService;
+    private readonly _pathService;
+    private _onIsCaughtUpWithContentChanges;
+    readonly onIsCaughtUpWithContentChanges: Event<URI>;
+    private readonly _proxy;
+    private readonly _modelTrackers;
+    private readonly _modelReferenceCollection;
+    constructor(extHostContext: IExtHostContext, _modelService: IModelService, _textFileService: ITextFileService, _fileService: IFileService, _textModelResolverService: ITextModelService, _environmentService: IWorkbenchEnvironmentService, _uriIdentityService: IUriIdentityService, workingCopyFileService: IWorkingCopyFileService, _pathService: IPathService);
+    dispose(): void;
+    isCaughtUpWithContentChanges(resource: URI): boolean;
+    private _shouldHandleFileEvent;
+    handleModelAdded(model: ITextModel): void;
+    private _onModelModeChanged;
+    handleModelRemoved(modelUrl: URI): void;
+    $trySaveDocument(uri: UriComponents): Promise<boolean>;
+    $tryOpenDocument(uriData: UriComponents): Promise<URI>;
+    $tryCreateDocument(options?: {
+        language?: string;
+        content?: string;
+    }): Promise<URI>;
+    private _handleAsResourceInput;
+    private _handleUntitledScheme;
+    private _doCreateUntitled;
+}