@codingame/monaco-vscode-api 1.83.15 → 1.85.0-next.0

package/vscode/src/vs/platform/terminal/common/capabilities/partialCommandDetectionCapability.js

@@ -0,0 +1,48 @@
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+class PartialCommandDetectionCapability extends DisposableStore {
+    get commands() { return this._commands; }
+    constructor(_terminal) {
+        super();
+        this._terminal = _terminal;
+        this.type = 3 ;
+        this._commands = [];
+        this._onCommandFinished = this.add(( new Emitter()));
+        this.onCommandFinished = this._onCommandFinished.event;
+        this.add(this._terminal.onData(e => this._onData(e)));
+        this.add(this._terminal.parser.registerCsiHandler({ final: 'J' }, params => {
+            if (params.length >= 1 && (params[0] === 2 || params[0] === 3)) {
+                this._clearCommandsInViewport();
+            }
+            return false;
+        }));
+    }
+    _onData(data) {
+        if (data === '\x0d') {
+            this._onEnter();
+        }
+    }
+    _onEnter() {
+        if (!this._terminal) {
+            return;
+        }
+        if (this._terminal.buffer.active.cursorX >= 2 ) {
+            const marker = this._terminal.registerMarker(0);
+            if (marker) {
+                this._commands.push(marker);
+                this._onCommandFinished.fire(marker);
+            }
+        }
+    }
+    _clearCommandsInViewport() {
+        let count = 0;
+        for (let i = this._commands.length - 1; i >= 0; i--) {
+            if (this._commands[i].line < this._terminal.buffer.active.baseY) {
+                break;
+            }
+            count++;
+        }
+        this._commands.splice(this._commands.length - count, count);
+    }
+}
+export { PartialCommandDetectionCapability };

package/vscode/src/vs/platform/terminal/common/capabilities/terminalCapabilityStore.js

@@ -0,0 +1,94 @@
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+class TerminalCapabilityStore extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._map = ( new Map());
+        this._onDidRemoveCapabilityType = this._register(( new Emitter()));
+        this.onDidRemoveCapabilityType = this._onDidRemoveCapabilityType.event;
+        this._onDidAddCapabilityType = this._register(( new Emitter()));
+        this.onDidAddCapabilityType = this._onDidAddCapabilityType.event;
+        this._onDidRemoveCapability = this._register(( new Emitter()));
+        this.onDidRemoveCapability = this._onDidRemoveCapability.event;
+        this._onDidAddCapability = this._register(( new Emitter()));
+        this.onDidAddCapability = this._onDidAddCapability.event;
+    }
+    get items() {
+        return ( this._map.keys());
+    }
+    add(capability, impl) {
+        this._map.set(capability, impl);
+        this._onDidAddCapabilityType.fire(capability);
+        this._onDidAddCapability.fire({ id: capability, capability: impl });
+    }
+    get(capability) {
+        return this._map.get(capability);
+    }
+    remove(capability) {
+        const impl = this._map.get(capability);
+        if (!impl) {
+            return;
+        }
+        this._map.delete(capability);
+        this._onDidRemoveCapabilityType.fire(capability);
+        this._onDidAddCapability.fire({ id: capability, capability: impl });
+    }
+    has(capability) {
+        return ( this._map.has(capability));
+    }
+}
+class TerminalCapabilityStoreMultiplexer extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._stores = [];
+        this._onDidRemoveCapabilityType = this._register(( new Emitter()));
+        this.onDidRemoveCapabilityType = this._onDidRemoveCapabilityType.event;
+        this._onDidAddCapabilityType = this._register(( new Emitter()));
+        this.onDidAddCapabilityType = this._onDidAddCapabilityType.event;
+        this._onDidRemoveCapability = this._register(( new Emitter()));
+        this.onDidRemoveCapability = this._onDidRemoveCapability.event;
+        this._onDidAddCapability = this._register(( new Emitter()));
+        this.onDidAddCapability = this._onDidAddCapability.event;
+    }
+    get items() {
+        return this._items();
+    }
+    *_items() {
+        for (const store of this._stores) {
+            for (const c of store.items) {
+                yield c;
+            }
+        }
+    }
+    has(capability) {
+        for (const store of this._stores) {
+            for (const c of store.items) {
+                if (c === capability) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    get(capability) {
+        for (const store of this._stores) {
+            const c = store.get(capability);
+            if (c) {
+                return c;
+            }
+        }
+        return undefined;
+    }
+    add(store) {
+        this._stores.push(store);
+        for (const capability of store.items) {
+            this._onDidAddCapabilityType.fire(capability);
+            this._onDidAddCapability.fire({ id: capability, capability: store.get(capability) });
+        }
+        this._register(store.onDidAddCapabilityType(e => this._onDidAddCapabilityType.fire(e)));
+        this._register(store.onDidAddCapability(e => this._onDidAddCapability.fire(e)));
+        this._register(store.onDidRemoveCapabilityType(e => this._onDidRemoveCapabilityType.fire(e)));
+        this._register(store.onDidRemoveCapability(e => this._onDidRemoveCapability.fire(e)));
+    }
+}
+export { TerminalCapabilityStore, TerminalCapabilityStoreMultiplexer };

package/vscode/src/vs/platform/terminal/common/terminalEnvironment.js

@@ -0,0 +1,37 @@
+import { OS } from 'monaco-editor/esm/vs/base/common/platform.js';
+function escapeNonWindowsPath(path) {
+    let newPath = path;
+    if (newPath.includes('\\')) {
+        newPath = newPath.replace(/\\/g, '\\\\');
+    }
+    const bannedChars = /[\`\$\|\&\>\~\#\!\^\*\;\<\"\']/g;
+    newPath = newPath.replace(bannedChars, '');
+    return `'${newPath}'`;
+}
+function collapseTildePath(path, userHome, separator) {
+    if (!path) {
+        return '';
+    }
+    if (!userHome) {
+        return path;
+    }
+    if (userHome.match(/[\/\\]$/)) {
+        userHome = userHome.slice(0, userHome.length - 1);
+    }
+    const normalizedPath = path.replace(/\\/g, '/').toLowerCase();
+    const normalizedUserHome = userHome.replace(/\\/g, '/').toLowerCase();
+    if (!normalizedPath.includes(normalizedUserHome)) {
+        return path;
+    }
+    return `~${separator}${path.slice(userHome.length + 1)}`;
+}
+function sanitizeCwd(cwd) {
+    if (cwd.match(/^['"].*['"]$/)) {
+        cwd = cwd.substring(1, cwd.length - 1);
+    }
+    if (OS === 1  && cwd && cwd[1] === ':') {
+        return cwd[0].toUpperCase() + cwd.substring(1);
+    }
+    return cwd;
+}
+export { collapseTildePath, escapeNonWindowsPath, sanitizeCwd };

package/vscode/src/vs/platform/terminal/common/terminalStrings.js

@@ -0,0 +1,16 @@
+function formatMessageForTerminal(message, options = {}) {
+    let result = '';
+    if (!options.excludeLeadingNewLine) {
+        result += '\r\n';
+    }
+    result += '\x1b[0m\x1b[7m * ';
+    if (options.loudFormatting) {
+        result += '\x1b[0;104m';
+    }
+    else {
+        result += '\x1b[0m';
+    }
+    result += ` ${message} \x1b[0m\n\r`;
+    return result;
+}
+export { formatMessageForTerminal };

package/vscode/src/vs/platform/terminal/common/xterm/shellIntegrationAddon.js

@@ -0,0 +1,319 @@
+import { Disposable, toDisposable, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { TerminalCapabilityStore } from '../capabilities/terminalCapabilityStore.js';
+import { CommandDetectionCapability } from '../capabilities/commandDetectionCapability.js';
+import { CwdDetectionCapability } from '../capabilities/cwdDetectionCapability.js';
+import { PartialCommandDetectionCapability } from '../capabilities/partialCommandDetectionCapability.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { BufferMarkCapability } from '../capabilities/bufferMarkCapability.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { sanitizeCwd } from '../terminalEnvironment.js';
+class ShellIntegrationAddon extends Disposable {
+    get status() { return this._status; }
+    constructor(_nonce, _disableTelemetry, _telemetryService, _logService) {
+        super();
+        this._nonce = _nonce;
+        this._disableTelemetry = _disableTelemetry;
+        this._telemetryService = _telemetryService;
+        this._logService = _logService;
+        this.capabilities = this._register(( new TerminalCapabilityStore()));
+        this._hasUpdatedTelemetry = false;
+        this._commonProtocolDisposables = [];
+        this._status = 0 ;
+        this._onDidChangeStatus = ( new Emitter());
+        this.onDidChangeStatus = this._onDidChangeStatus.event;
+        this._register(toDisposable(() => {
+            this._clearActivationTimeout();
+            this._disposeCommonProtocol();
+        }));
+    }
+    _disposeCommonProtocol() {
+        dispose(this._commonProtocolDisposables);
+        this._commonProtocolDisposables.length = 0;
+    }
+    activate(xterm) {
+        this._terminal = xterm;
+        this.capabilities.add(3 , this._register(( new PartialCommandDetectionCapability(this._terminal))));
+        this._register(xterm.parser.registerOscHandler(633 , data => this._handleVSCodeSequence(data)));
+        this._register(xterm.parser.registerOscHandler(1337 , data => this._doHandleITermSequence(data)));
+        this._commonProtocolDisposables.push(xterm.parser.registerOscHandler(133 , data => this._handleFinalTermSequence(data)));
+        this._register(xterm.parser.registerOscHandler(7 , data => this._doHandleSetCwd(data)));
+        this._register(xterm.parser.registerOscHandler(9 , data => this._doHandleSetWindowsFriendlyCwd(data)));
+        this._ensureCapabilitiesOrAddFailureTelemetry();
+    }
+    getMarkerId(terminal, vscodeMarkerId) {
+        this._createOrGetBufferMarkDetection(terminal).getMark(vscodeMarkerId);
+    }
+    _handleFinalTermSequence(data) {
+        const didHandle = this._doHandleFinalTermSequence(data);
+        if (this._status === 0 ) {
+            this._status = 1 ;
+            this._onDidChangeStatus.fire(this._status);
+        }
+        return didHandle;
+    }
+    _doHandleFinalTermSequence(data) {
+        if (!this._terminal) {
+            return false;
+        }
+        const [command, ...args] = data.split(';');
+        switch (command) {
+            case 'A':
+                this._createOrGetCommandDetection(this._terminal).handlePromptStart();
+                return true;
+            case 'B':
+                this._createOrGetCommandDetection(this._terminal).handleCommandStart({ ignoreCommandLine: true });
+                return true;
+            case 'C':
+                this._createOrGetCommandDetection(this._terminal).handleCommandExecuted();
+                return true;
+            case 'D': {
+                const exitCode = args.length === 1 ? parseInt(args[0]) : undefined;
+                this._createOrGetCommandDetection(this._terminal).handleCommandFinished(exitCode);
+                return true;
+            }
+        }
+        return false;
+    }
+    _handleVSCodeSequence(data) {
+        const didHandle = this._doHandleVSCodeSequence(data);
+        if (!this._hasUpdatedTelemetry && didHandle) {
+            this._telemetryService?.publicLog2('terminal/shellIntegrationActivationSucceeded');
+            this._hasUpdatedTelemetry = true;
+            this._clearActivationTimeout();
+        }
+        if (this._status !== 2 ) {
+            this._status = 2 ;
+            this._onDidChangeStatus.fire(this._status);
+        }
+        return didHandle;
+    }
+    async _ensureCapabilitiesOrAddFailureTelemetry() {
+        if (!this._telemetryService || this._disableTelemetry) {
+            return;
+        }
+        this._activationTimeout = setTimeout(() => {
+            if (!this.capabilities.get(2 ) && !this.capabilities.get(0 )) {
+                this._telemetryService?.publicLog2('terminal/shellIntegrationActivationTimeout');
+                this._logService.warn('Shell integration failed to add capabilities within 10 seconds');
+            }
+            this._hasUpdatedTelemetry = true;
+        }, 10000);
+    }
+    _clearActivationTimeout() {
+        if (this._activationTimeout !== undefined) {
+            clearTimeout(this._activationTimeout);
+            this._activationTimeout = undefined;
+        }
+    }
+    _doHandleVSCodeSequence(data) {
+        if (!this._terminal) {
+            return false;
+        }
+        const argsIndex = data.indexOf(';');
+        const sequenceCommand = argsIndex === -1 ? data : data.substring(0, argsIndex);
+        const args = argsIndex === -1 ? [] : data.substring(argsIndex + 1).split(';');
+        switch (sequenceCommand) {
+            case "A" :
+                this._createOrGetCommandDetection(this._terminal).handlePromptStart();
+                return true;
+            case "B" :
+                this._createOrGetCommandDetection(this._terminal).handleCommandStart();
+                return true;
+            case "C" :
+                this._createOrGetCommandDetection(this._terminal).handleCommandExecuted();
+                return true;
+            case "D" : {
+                const arg0 = args[0];
+                const exitCode = arg0 !== undefined ? parseInt(arg0) : undefined;
+                this._createOrGetCommandDetection(this._terminal).handleCommandFinished(exitCode);
+                return true;
+            }
+            case "E" : {
+                const arg0 = args[0];
+                const arg1 = args[1];
+                let commandLine;
+                if (arg0 !== undefined) {
+                    commandLine = deserializeMessage(arg0);
+                }
+                else {
+                    commandLine = '';
+                }
+                this._createOrGetCommandDetection(this._terminal).setCommandLine(commandLine, arg1 === this._nonce);
+                return true;
+            }
+            case "F" : {
+                this._createOrGetCommandDetection(this._terminal).handleContinuationStart();
+                return true;
+            }
+            case "G" : {
+                this._createOrGetCommandDetection(this._terminal).handleContinuationEnd();
+                return true;
+            }
+            case "H" : {
+                this._createOrGetCommandDetection(this._terminal).handleRightPromptStart();
+                return true;
+            }
+            case "I" : {
+                this._createOrGetCommandDetection(this._terminal).handleRightPromptEnd();
+                return true;
+            }
+            case "P" : {
+                const arg0 = args[0];
+                const deserialized = arg0 !== undefined ? deserializeMessage(arg0) : '';
+                const { key, value } = parseKeyValueAssignment(deserialized);
+                if (value === undefined) {
+                    return true;
+                }
+                switch (key) {
+                    case 'Cwd': {
+                        this._updateCwd(value);
+                        return true;
+                    }
+                    case 'IsWindows': {
+                        this._createOrGetCommandDetection(this._terminal).setIsWindowsPty(value === 'True' ? true : false);
+                        return true;
+                    }
+                    case 'Task': {
+                        this._createOrGetBufferMarkDetection(this._terminal);
+                        this.capabilities.get(2 )?.setIsCommandStorageDisabled();
+                        return true;
+                    }
+                }
+            }
+            case "SetMark" : {
+                this._createOrGetBufferMarkDetection(this._terminal).addMark(parseMarkSequence(args));
+                return true;
+            }
+        }
+        return false;
+    }
+    _updateCwd(value) {
+        value = sanitizeCwd(value);
+        this._createOrGetCwdDetection().updateCwd(value);
+        const commandDetection = this.capabilities.get(2 );
+        commandDetection?.setCwd(value);
+    }
+    _doHandleITermSequence(data) {
+        if (!this._terminal) {
+            return false;
+        }
+        const [command] = data.split(';');
+        switch (command) {
+            case "SetMark" : {
+                this._createOrGetBufferMarkDetection(this._terminal).addMark();
+            }
+            default: {
+                const { key, value } = parseKeyValueAssignment(command);
+                if (value === undefined) {
+                    return true;
+                }
+                switch (key) {
+                    case "CurrentDir" :
+                        this._updateCwd(value);
+                        return true;
+                }
+            }
+        }
+        return false;
+    }
+    _doHandleSetWindowsFriendlyCwd(data) {
+        if (!this._terminal) {
+            return false;
+        }
+        const [command, ...args] = data.split(';');
+        switch (command) {
+            case '9':
+                if (args.length) {
+                    this._updateCwd(args[0]);
+                }
+                return true;
+        }
+        return false;
+    }
+    _doHandleSetCwd(data) {
+        if (!this._terminal) {
+            return false;
+        }
+        const [command] = data.split(';');
+        if (command.match(/^file:\/\/.*\//)) {
+            const uri = ( URI.parse(command));
+            if (uri.path && uri.path.length > 0) {
+                this._updateCwd(uri.path);
+                return true;
+            }
+        }
+        return false;
+    }
+    serialize() {
+        if (!this._terminal || !( this.capabilities.has(2 ))) {
+            return {
+                isWindowsPty: false,
+                commands: []
+            };
+        }
+        const result = this._createOrGetCommandDetection(this._terminal).serialize();
+        return result;
+    }
+    deserialize(serialized) {
+        if (!this._terminal) {
+            throw new Error('Cannot restore commands before addon is activated');
+        }
+        this._createOrGetCommandDetection(this._terminal).deserialize(serialized);
+    }
+    _createOrGetCwdDetection() {
+        let cwdDetection = this.capabilities.get(0 );
+        if (!cwdDetection) {
+            cwdDetection = this._register(( new CwdDetectionCapability()));
+            this.capabilities.add(0 , cwdDetection);
+        }
+        return cwdDetection;
+    }
+    _createOrGetCommandDetection(terminal) {
+        let commandDetection = this.capabilities.get(2 );
+        if (!commandDetection) {
+            commandDetection = this._register(( new CommandDetectionCapability(terminal, this._logService)));
+            this.capabilities.add(2 , commandDetection);
+        }
+        return commandDetection;
+    }
+    _createOrGetBufferMarkDetection(terminal) {
+        let bufferMarkDetection = this.capabilities.get(4 );
+        if (!bufferMarkDetection) {
+            bufferMarkDetection = this._register(( new BufferMarkCapability(terminal)));
+            this.capabilities.add(4 , bufferMarkDetection);
+        }
+        return bufferMarkDetection;
+    }
+}
+function deserializeMessage(message) {
+    return message.replaceAll(
+    /\\(\\|x([0-9a-f]{2}))/gi,
+    (_match, op, hex) => hex ? String.fromCharCode(parseInt(hex, 16)) : op);
+}
+function parseKeyValueAssignment(message) {
+    const separatorIndex = message.indexOf('=');
+    if (separatorIndex === -1) {
+        return { key: message, value: undefined };
+    }
+    return {
+        key: message.substring(0, separatorIndex),
+        value: message.substring(1 + separatorIndex)
+    };
+}
+function parseMarkSequence(sequence) {
+    let id = undefined;
+    let hidden = false;
+    for (const property of sequence) {
+        if (property === undefined) {
+            continue;
+        }
+        if (property === 'Hidden') {
+            hidden = true;
+        }
+        if (property.startsWith('Id=')) {
+            id = property.substring(3);
+        }
+    }
+    return { id, hidden };
+}
+export { ShellIntegrationAddon, deserializeMessage, parseKeyValueAssignment, parseMarkSequence };

package/vscode/src/vs/platform/window/common/window.d.ts

@@ -2,6 +2,14 @@ import { URI, UriComponents } from '../../../base/common/uri.js';
 import { IEditorOptions } from '../../editor/common/editor.js';
 import { FileType } from '../../files/common/files.js';
 
+interface IPoint {
+    readonly x: number;
+    readonly y: number;
+}
+interface IRectangle extends IPoint {
+    readonly width: number;
+    readonly height: number;
+}
 interface IBaseOpenWindowsOptions {
     /**
      * Whether to reuse the window or open a new one.
@@ -43,7 +51,6 @@ interface IFolderToOpen extends IBaseWindowOpenable {
 interface IFileToOpen extends IBaseWindowOpenable {
     readonly fileUri: URI;
 }
-type MenuBarVisibility = 'classic' | 'visible' | 'toggle' | 'hidden' | 'compact';
 interface IPath<T = IEditorOptions> extends IPathData<T> {
     /**
      * The file path to open within the instance
@@ -77,4 +84,4 @@ interface IPathData<T = IEditorOptions> {
     readonly openOnlyIfExists?: boolean;
 }
 
-export type { IBaseOpenWindowsOptions, IBaseWindowOpenable, IFileToOpen, IFolderToOpen, IOpenEmptyWindowOptions, IOpenWindowOptions, IPath, IPathData, IWindowOpenable, IWorkspaceToOpen, MenuBarVisibility };
+export type { IBaseOpenWindowsOptions, IBaseWindowOpenable, IFileToOpen, IFolderToOpen, IOpenEmptyWindowOptions, IOpenWindowOptions, IPath, IPathData, IPoint, IRectangle, IWindowOpenable, IWorkspaceToOpen };

package/vscode/src/vs/platform/window/common/window.js

@@ -1,4 +1,9 @@
 import { isMacintosh, isNative, isWeb, isLinux } from 'monaco-editor/esm/vs/base/common/platform.js';
+const WindowMinimumSize = {
+    WIDTH: 400,
+    WIDTH_WITH_VERTICAL_PANEL: 600,
+    HEIGHT: 270
+};
 function isWorkspaceToOpen(uriToOpen) {
     return !!uriToOpen.workspaceUri;
 }
@@ -39,4 +44,4 @@ function getTitleBarStyle(configurationService) {
     }
     return isLinux ? 'native' : 'custom';
 }
-export { getMenuBarVisibility, getTitleBarStyle, isFileToOpen, isFolderToOpen, isWorkspaceToOpen };
+export { WindowMinimumSize, getMenuBarVisibility, getTitleBarStyle, isFileToOpen, isFolderToOpen, isWorkspaceToOpen };

package/vscode/src/vs/platform/workspaces/common/workspaces.d.ts

@@ -1,43 +1,6 @@
-import { ServiceIdentifier } from '../../instantiation/common/instantiation.js';
-import { Event } from '../../../base/common/event.js';
 import { URI } from '../../../base/common/uri.js';
-import { IWorkspaceBackupInfo, IFolderBackupInfo } from '../../backup/common/backup.js';
-import { IBaseWorkspace, IRawFileWorkspaceFolder, IRawUriWorkspaceFolder, IWorkspaceIdentifier } from '../../workspace/common/workspace.js';
+import { IBaseWorkspace, IRawFileWorkspaceFolder, IRawUriWorkspaceFolder } from '../../workspace/common/workspace.js';
 
-declare const IWorkspacesService: ServiceIdentifier<IWorkspacesService>;
-interface IWorkspacesService {
-    readonly _serviceBrand: undefined;
-    enterWorkspace(workspaceUri: URI): Promise<IEnterWorkspaceResult | undefined>;
-    createUntitledWorkspace(folders?: IWorkspaceFolderCreationData[], remoteAuthority?: string): Promise<IWorkspaceIdentifier>;
-    deleteUntitledWorkspace(workspace: IWorkspaceIdentifier): Promise<void>;
-    getWorkspaceIdentifier(workspaceUri: URI): Promise<IWorkspaceIdentifier>;
-    readonly onDidChangeRecentlyOpened: Event<void>;
-    addRecentlyOpened(recents: IRecent[]): Promise<void>;
-    removeRecentlyOpened(workspaces: URI[]): Promise<void>;
-    clearRecentlyOpened(): Promise<void>;
-    getRecentlyOpened(): Promise<IRecentlyOpened>;
-    getDirtyWorkspaces(): Promise<Array<IWorkspaceBackupInfo | IFolderBackupInfo>>;
-}
-interface IRecentlyOpened {
-    workspaces: Array<IRecentWorkspace | IRecentFolder>;
-    files: IRecentFile[];
-}
-type IRecent = IRecentWorkspace | IRecentFolder | IRecentFile;
-interface IRecentWorkspace {
-    readonly workspace: IWorkspaceIdentifier;
-    label?: string;
-    readonly remoteAuthority?: string;
-}
-interface IRecentFolder {
-    readonly folderUri: URI;
-    label?: string;
-    readonly remoteAuthority?: string;
-}
-interface IRecentFile {
-    readonly fileUri: URI;
-    label?: string;
-    readonly remoteAuthority?: string;
-}
 type IStoredWorkspaceFolder = IRawFileWorkspaceFolder | IRawUriWorkspaceFolder;
 interface IStoredWorkspace extends IBaseWorkspace {
     folders: IStoredWorkspaceFolder[];
@@ -46,9 +9,5 @@ interface IWorkspaceFolderCreationData {
     readonly uri: URI;
     readonly name?: string;
 }
-interface IEnterWorkspaceResult {
-    readonly workspace: IWorkspaceIdentifier;
-    readonly backupPath?: string;
-}
 
-export { type IEnterWorkspaceResult, type IRecent, type IRecentFile, type IRecentFolder, type IRecentWorkspace, type IRecentlyOpened, type IStoredWorkspace, type IStoredWorkspaceFolder, type IWorkspaceFolderCreationData, IWorkspacesService };
+export type { IStoredWorkspace, IStoredWorkspaceFolder, IWorkspaceFolderCreationData };