@codingame/monaco-vscode-api 4.4.1 → 4.5.0

package/vscode/src/vs/workbench/services/progress/browser/progressService.js

@@ -1,521 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import './media/progressService.css.js';
-import { localizeWithPath } from '../../../../nls.js';
-import { Disposable, dispose, DisposableStore, toDisposable } from '../../../../base/common/lifecycle.js';
-import { Progress } from '../../../../platform/progress/common/progress.js';
-import { IStatusbarService } from '../../statusbar/browser/statusbar.js';
-import { timeout, RunOnceScheduler, DeferredPromise } from '../../../../base/common/async.js';
-import { ProgressBadge, IActivityService } from '../../activity/common/activity.js';
-import { NotificationPriority, NotificationsFilter, isNotificationSource, INotificationService, Severity } from '../../../../platform/notification/common/notification.js';
-import { Action } from '../../../../base/common/actions.js';
-import { Emitter, Event } from '../../../../base/common/event.js';
-import { ILayoutService } from '../../../../platform/layout/browser/layoutService.js';
-import { Dialog } from '../../../../base/browser/ui/dialog/dialog.js';
-import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.js';
-import { EventHelper } from '../../../../base/browser/dom.js';
-import { parseLinkedText } from '../../../../base/common/linkedText.js';
-import { IViewDescriptorService } from '../../../common/views.js';
-import { IViewsService } from '../../views/common/viewsService.js';
-import { IPaneCompositePartService } from '../../panecomposite/browser/panecomposite.js';
-import { stripIcons } from '../../../../base/common/iconLabels.js';
-import { defaultButtonStyles, defaultCheckboxStyles, defaultInputBoxStyles, defaultDialogStyles } from '../../../../platform/theme/browser/defaultStyles.js';
-let ProgressService = class ProgressService extends Disposable {
-    constructor(activityService, paneCompositeService, viewDescriptorService, viewsService, notificationService, statusbarService, layoutService, keybindingService) {
-        super();
-        this.activityService = activityService;
-        this.paneCompositeService = paneCompositeService;
-        this.viewDescriptorService = viewDescriptorService;
-        this.viewsService = viewsService;
-        this.notificationService = notificationService;
-        this.statusbarService = statusbarService;
-        this.layoutService = layoutService;
-        this.keybindingService = keybindingService;
-        this.windowProgressStack = [];
-        this.windowProgressStatusEntry = undefined;
-    }
-    async withProgress(options, task, onDidCancel) {
-        const { location } = options;
-        const handleStringLocation = (location) => {
-            const viewContainer = this.viewDescriptorService.getViewContainerById(location);
-            if (viewContainer) {
-                const viewContainerLocation = this.viewDescriptorService.getViewContainerLocation(viewContainer);
-                if (viewContainerLocation !== null) {
-                    return this.withPaneCompositeProgress(location, viewContainerLocation, task, { ...options, location });
-                }
-            }
-            if (this.viewDescriptorService.getViewDescriptorById(location) !== null) {
-                return this.withViewProgress(location, task, { ...options, location });
-            }
-            throw new Error(`Bad progress location: ${location}`);
-        };
-        if (typeof location === 'string') {
-            return handleStringLocation(location);
-        }
-        switch (location) {
-            case 15 : {
-                let priority = options.priority;
-                if (priority !== NotificationPriority.URGENT) {
-                    if (this.notificationService.getFilter() === NotificationsFilter.ERROR) {
-                        priority = NotificationPriority.SILENT;
-                    }
-                    else if (isNotificationSource(options.source) && this.notificationService.getFilter(options.source) === NotificationsFilter.ERROR) {
-                        priority = NotificationPriority.SILENT;
-                    }
-                }
-                return this.withNotificationProgress({ ...options, location, priority }, task, onDidCancel);
-            }
-            case 10 : {
-                const type = options.type;
-                if (options.command) {
-                    return this.withWindowProgress({ ...options, location, type }, task);
-                }
-                return this.withNotificationProgress({ delay: 150 , ...options, priority: NotificationPriority.SILENT, location: 15 , type }, task, onDidCancel);
-            }
-            case 1 :
-                return this.withPaneCompositeProgress('workbench.view.explorer', 0 , task, { ...options, location });
-            case 3 :
-                return handleStringLocation('workbench.scm');
-            case 5 :
-                return this.withPaneCompositeProgress('workbench.view.extensions', 0 , task, { ...options, location });
-            case 20 :
-                return this.withDialogProgress(options, task, onDidCancel);
-            default:
-                throw new Error(`Bad progress location: ${location}`);
-        }
-    }
-    withWindowProgress(options, callback) {
-        const task = [options, ( new Progress(() => this.updateWindowProgress()))];
-        const promise = callback(task[1]);
-        let delayHandle = setTimeout(() => {
-            delayHandle = undefined;
-            this.windowProgressStack.unshift(task);
-            this.updateWindowProgress();
-            Promise.all([
-                timeout(150),
-                promise
-            ]).finally(() => {
-                const idx = this.windowProgressStack.indexOf(task);
-                this.windowProgressStack.splice(idx, 1);
-                this.updateWindowProgress();
-            });
-        }, 150);
-        return promise.finally(() => clearTimeout(delayHandle));
-    }
-    updateWindowProgress(idx = 0) {
-        if (idx < this.windowProgressStack.length) {
-            const [options, progress] = this.windowProgressStack[idx];
-            const progressTitle = options.title;
-            const progressMessage = progress.value && progress.value.message;
-            const progressCommand = options.command;
-            let text;
-            let title;
-            const source = options.source && typeof options.source !== 'string' ? options.source.label : options.source;
-            if (progressTitle && progressMessage) {
-                text = ( localizeWithPath(
-                    'vs/workbench/services/progress/browser/progressService',
-                    'progress.text2',
-                    "{0}: {1}",
-                    progressTitle,
-                    progressMessage
-                ));
-                title = source ? ( localizeWithPath(
-                    'vs/workbench/services/progress/browser/progressService',
-                    'progress.title3',
-                    "[{0}] {1}: {2}",
-                    source,
-                    progressTitle,
-                    progressMessage
-                )) : text;
-            }
-            else if (progressTitle) {
-                text = progressTitle;
-                title = source ? ( localizeWithPath(
-                    'vs/workbench/services/progress/browser/progressService',
-                    'progress.title2',
-                    "[{0}]: {1}",
-                    source,
-                    progressTitle
-                )) : text;
-            }
-            else if (progressMessage) {
-                text = progressMessage;
-                title = source ? ( localizeWithPath(
-                    'vs/workbench/services/progress/browser/progressService',
-                    'progress.title2',
-                    "[{0}]: {1}",
-                    source,
-                    progressMessage
-                )) : text;
-            }
-            else {
-                this.updateWindowProgress(idx + 1);
-                return;
-            }
-            const statusEntryProperties = {
-                name: ( localizeWithPath(
-                    'vs/workbench/services/progress/browser/progressService',
-                    'status.progress',
-                    "Progress Message"
-                )),
-                text,
-                showProgress: options.type || true,
-                ariaLabel: text,
-                tooltip: title,
-                command: progressCommand
-            };
-            if (this.windowProgressStatusEntry) {
-                this.windowProgressStatusEntry.update(statusEntryProperties);
-            }
-            else {
-                this.windowProgressStatusEntry = this.statusbarService.addEntry(statusEntryProperties, 'status.progress', 0 );
-            }
-        }
-        else {
-            this.windowProgressStatusEntry?.dispose();
-            this.windowProgressStatusEntry = undefined;
-        }
-    }
-    withNotificationProgress(options, callback, onDidCancel) {
-        const progressStateModel = new (class extends Disposable {
-            get step() { return this._step; }
-            get done() { return this._done; }
-            constructor() {
-                super();
-                this._onDidReport = this._register(( new Emitter()));
-                this.onDidReport = this._onDidReport.event;
-                this._onWillDispose = this._register(( new Emitter()));
-                this.onWillDispose = this._onWillDispose.event;
-                this._step = undefined;
-                this._done = false;
-                this.promise = callback(this);
-                this.promise.finally(() => {
-                    this.dispose();
-                });
-            }
-            report(step) {
-                this._step = step;
-                this._onDidReport.fire(step);
-            }
-            cancel(choice) {
-                onDidCancel?.(choice);
-                this.dispose();
-            }
-            dispose() {
-                this._done = true;
-                this._onWillDispose.fire();
-                super.dispose();
-            }
-        });
-        const createWindowProgress = () => {
-            const promise = ( new DeferredPromise());
-            this.withWindowProgress({
-                location: 10 ,
-                title: options.title ? ( parseLinkedText(options.title).toString()) : undefined,
-                command: 'notifications.showList',
-                type: options.type
-            }, progress => {
-                function reportProgress(step) {
-                    if (step.message) {
-                        progress.report({
-                            message: ( parseLinkedText(step.message).toString())
-                        });
-                    }
-                }
-                if (progressStateModel.step) {
-                    reportProgress(progressStateModel.step);
-                }
-                const onDidReportListener = progressStateModel.onDidReport(step => reportProgress(step));
-                promise.p.finally(() => onDidReportListener.dispose());
-                Event.once(progressStateModel.onWillDispose)(() => promise.complete());
-                return promise.p;
-            });
-            return toDisposable(() => promise.complete());
-        };
-        const createNotification = (message, priority, increment) => {
-            const notificationDisposables = ( new DisposableStore());
-            const primaryActions = options.primaryActions ? Array.from(options.primaryActions) : [];
-            const secondaryActions = options.secondaryActions ? Array.from(options.secondaryActions) : [];
-            if (options.buttons) {
-                options.buttons.forEach((button, index) => {
-                    const buttonAction = new (class extends Action {
-                        constructor() {
-                            super(`progress.button.${button}`, button, undefined, true);
-                        }
-                        async run() {
-                            progressStateModel.cancel(index);
-                        }
-                    });
-                    notificationDisposables.add(buttonAction);
-                    primaryActions.push(buttonAction);
-                });
-            }
-            if (options.cancellable) {
-                const cancelAction = new (class extends Action {
-                    constructor() {
-                        super('progress.cancel', ( localizeWithPath(
-                            'vs/workbench/services/progress/browser/progressService',
-                            'cancel',
-                            "Cancel"
-                        )), undefined, true);
-                    }
-                    async run() {
-                        progressStateModel.cancel();
-                    }
-                });
-                notificationDisposables.add(cancelAction);
-                primaryActions.push(cancelAction);
-            }
-            const notification = this.notificationService.notify({
-                severity: Severity.Info,
-                message: stripIcons(message),
-                source: options.source,
-                actions: { primary: primaryActions, secondary: secondaryActions },
-                progress: typeof increment === 'number' && increment >= 0 ? { total: 100, worked: increment } : { infinite: true },
-                priority
-            });
-            let windowProgressDisposable = undefined;
-            const onVisibilityChange = (visible) => {
-                dispose(windowProgressDisposable);
-                if (!visible && !progressStateModel.done) {
-                    windowProgressDisposable = createWindowProgress();
-                }
-            };
-            notificationDisposables.add(notification.onDidChangeVisibility(onVisibilityChange));
-            if (priority === NotificationPriority.SILENT) {
-                onVisibilityChange(false);
-            }
-            Event.once(notification.onDidClose)(() => notificationDisposables.dispose());
-            return notification;
-        };
-        const updateProgress = (notification, increment) => {
-            if (typeof increment === 'number' && increment >= 0) {
-                notification.progress.total(100);
-                notification.progress.worked(increment);
-            }
-            else {
-                notification.progress.infinite();
-            }
-        };
-        let notificationHandle;
-        let notificationTimeout;
-        let titleAndMessage;
-        const updateNotification = (step) => {
-            if (step?.message && options.title) {
-                titleAndMessage = `${options.title}: ${step.message}`;
-            }
-            else {
-                titleAndMessage = options.title || step?.message;
-            }
-            if (!notificationHandle && titleAndMessage) {
-                if (typeof options.delay === 'number' && options.delay > 0) {
-                    if (typeof notificationTimeout !== 'number') {
-                        notificationTimeout = setTimeout(() => notificationHandle = createNotification(titleAndMessage, options.priority, step?.increment), options.delay);
-                    }
-                }
-                else {
-                    notificationHandle = createNotification(titleAndMessage, options.priority, step?.increment);
-                }
-            }
-            if (notificationHandle) {
-                if (titleAndMessage) {
-                    notificationHandle.updateMessage(titleAndMessage);
-                }
-                if (typeof step?.increment === 'number') {
-                    updateProgress(notificationHandle, step.increment);
-                }
-            }
-        };
-        updateNotification(progressStateModel.step);
-        const listener = progressStateModel.onDidReport(step => updateNotification(step));
-        Event.once(progressStateModel.onWillDispose)(() => listener.dispose());
-        (async () => {
-            try {
-                if (typeof options.delay === 'number' && options.delay > 0) {
-                    await progressStateModel.promise;
-                }
-                else {
-                    await Promise.all([timeout(800), progressStateModel.promise]);
-                }
-            }
-            finally {
-                clearTimeout(notificationTimeout);
-                notificationHandle?.close();
-            }
-        })();
-        return progressStateModel.promise;
-    }
-    withPaneCompositeProgress(paneCompositeId, viewContainerLocation, task, options) {
-        const progressIndicator = this.paneCompositeService.getProgressIndicator(paneCompositeId, viewContainerLocation);
-        const promise = progressIndicator ? this.withCompositeProgress(progressIndicator, task, options) : task({ report: () => { } });
-        if (viewContainerLocation === 0 ) {
-            this.showOnActivityBar(paneCompositeId, options, promise);
-        }
-        return promise;
-    }
-    withViewProgress(viewId, task, options) {
-        const progressIndicator = this.viewsService.getViewProgressIndicator(viewId);
-        const promise = progressIndicator ? this.withCompositeProgress(progressIndicator, task, options) : task({ report: () => { } });
-        const location = this.viewDescriptorService.getViewLocationById(viewId);
-        if (location !== 0 ) {
-            return promise;
-        }
-        const viewletId = this.viewDescriptorService.getViewContainerByViewId(viewId)?.id;
-        if (viewletId === undefined) {
-            return promise;
-        }
-        this.showOnActivityBar(viewletId, options, promise);
-        return promise;
-    }
-    showOnActivityBar(viewletId, options, promise) {
-        let activityProgress;
-        let delayHandle = setTimeout(() => {
-            delayHandle = undefined;
-            const handle = this.activityService.showViewContainerActivity(viewletId, { badge: ( new ProgressBadge(() => '')), priority: 100 });
-            const startTimeVisible = Date.now();
-            const minTimeVisible = 300;
-            activityProgress = {
-                dispose() {
-                    const d = Date.now() - startTimeVisible;
-                    if (d < minTimeVisible) {
-                        setTimeout(() => handle.dispose(), minTimeVisible - d);
-                    }
-                    else {
-                        handle.dispose();
-                    }
-                }
-            };
-        }, options.delay || 300);
-        promise.finally(() => {
-            clearTimeout(delayHandle);
-            dispose(activityProgress);
-        });
-    }
-    withCompositeProgress(progressIndicator, task, options) {
-        let discreteProgressRunner = undefined;
-        function updateProgress(stepOrTotal) {
-            let total = undefined;
-            let increment = undefined;
-            if (typeof stepOrTotal !== 'undefined') {
-                if (typeof stepOrTotal === 'number') {
-                    total = stepOrTotal;
-                }
-                else if (typeof stepOrTotal.increment === 'number') {
-                    total = stepOrTotal.total ?? 100;
-                    increment = stepOrTotal.increment;
-                }
-            }
-            if (typeof total === 'number') {
-                if (!discreteProgressRunner) {
-                    discreteProgressRunner = progressIndicator.show(total, options.delay);
-                    promise.catch(() => undefined ).finally(() => discreteProgressRunner?.done());
-                }
-                if (typeof increment === 'number') {
-                    discreteProgressRunner.worked(increment);
-                }
-            }
-            else {
-                discreteProgressRunner?.done();
-                progressIndicator.showWhile(promise, options.delay);
-            }
-            return discreteProgressRunner;
-        }
-        const promise = task({
-            report: progress => {
-                updateProgress(progress);
-            }
-        });
-        updateProgress(options.total);
-        return promise;
-    }
-    withDialogProgress(options, task, onDidCancel) {
-        const disposables = ( new DisposableStore());
-        const allowableCommands = [
-            'workbench.action.quit',
-            'workbench.action.reloadWindow',
-            'copy',
-            'cut',
-            'editor.action.clipboardCopyAction',
-            'editor.action.clipboardCutAction'
-        ];
-        let dialog;
-        const createDialog = (message) => {
-            const buttons = options.buttons || [];
-            if (!options.sticky) {
-                buttons.push(options.cancellable ? ( localizeWithPath(
-                    'vs/workbench/services/progress/browser/progressService',
-                    'cancel',
-                    "Cancel"
-                )) : ( localizeWithPath(
-                    'vs/workbench/services/progress/browser/progressService',
-                    'dismiss',
-                    "Dismiss"
-                )));
-            }
-            dialog = ( new Dialog(this.layoutService.activeContainer, message, buttons, {
-                type: 'pending',
-                detail: options.detail,
-                cancelId: buttons.length - 1,
-                disableCloseAction: options.sticky,
-                disableDefaultAction: options.sticky,
-                keyEventProcessor: (event) => {
-                    const resolved = this.keybindingService.softDispatch(event, this.layoutService.activeContainer);
-                    if (resolved.kind === 2  && resolved.commandId) {
-                        if (!allowableCommands.includes(resolved.commandId)) {
-                            EventHelper.stop(event, true);
-                        }
-                    }
-                },
-                buttonStyles: defaultButtonStyles,
-                checkboxStyles: defaultCheckboxStyles,
-                inputBoxStyles: defaultInputBoxStyles,
-                dialogStyles: defaultDialogStyles
-            }));
-            disposables.add(dialog);
-            dialog.show().then(dialogResult => {
-                onDidCancel?.(dialogResult.button);
-                dispose(dialog);
-            });
-            return dialog;
-        };
-        let delay = options.delay ?? 0;
-        let latestMessage = undefined;
-        const scheduler = disposables.add(( new RunOnceScheduler(() => {
-            delay = 0;
-            if (latestMessage && !dialog) {
-                dialog = createDialog(latestMessage);
-            }
-            else if (latestMessage) {
-                dialog.updateMessage(latestMessage);
-            }
-        }, 0)));
-        const updateDialog = function (message) {
-            latestMessage = message;
-            if (!scheduler.isScheduled()) {
-                scheduler.schedule(delay);
-            }
-        };
-        const promise = task({
-            report: progress => {
-                updateDialog(progress.message);
-            }
-        });
-        promise.finally(() => {
-            dispose(disposables);
-        });
-        if (options.title) {
-            updateDialog(options.title);
-        }
-        return promise;
-    }
-};
-ProgressService = ( __decorate([
-    ( __param(0, IActivityService)),
-    ( __param(1, IPaneCompositePartService)),
-    ( __param(2, IViewDescriptorService)),
-    ( __param(3, IViewsService)),
-    ( __param(4, INotificationService)),
-    ( __param(5, IStatusbarService)),
-    ( __param(6, ILayoutService)),
-    ( __param(7, IKeybindingService))
-], ProgressService));
-export { ProgressService };

package/vscode/src/vs/workbench/services/remote/common/remoteAgentService.js

@@ -1,59 +0,0 @@
-import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
-import { timeout } from '../../../../base/common/async.js';
-const IRemoteAgentService = ( createDecorator('remoteAgentService'));
-const remoteConnectionLatencyMeasurer = new (class {
-    constructor() {
-        this.maxSampleCount = 5;
-        this.sampleDelay = 2000;
-        this.initial = [];
-        this.maxInitialCount = 3;
-        this.average = [];
-        this.maxAverageCount = 100;
-        this.highLatencyMultiple = 2;
-        this.highLatencyMinThreshold = 500;
-        this.highLatencyMaxThreshold = 1500;
-        this.lastMeasurement = undefined;
-    }
-    get latency() { return this.lastMeasurement; }
-    async measure(remoteAgentService) {
-        let currentLatency = Infinity;
-        for (let i = 0; i < this.maxSampleCount; i++) {
-            const rtt = await remoteAgentService.getRoundTripTime();
-            if (rtt === undefined) {
-                return undefined;
-            }
-            currentLatency = Math.min(currentLatency, rtt / 2 );
-            await timeout(this.sampleDelay);
-        }
-        this.average.push(currentLatency);
-        if (this.average.length > this.maxAverageCount) {
-            this.average.shift();
-        }
-        let initialLatency = undefined;
-        if (this.initial.length < this.maxInitialCount) {
-            this.initial.push(currentLatency);
-        }
-        else {
-            initialLatency = this.initial.reduce((sum, value) => sum + value, 0) / this.initial.length;
-        }
-        this.lastMeasurement = {
-            initial: initialLatency,
-            current: currentLatency,
-            average: this.average.reduce((sum, value) => sum + value, 0) / this.average.length,
-            high: (() => {
-                if (typeof initialLatency === 'undefined') {
-                    return false;
-                }
-                if (currentLatency > this.highLatencyMaxThreshold) {
-                    return true;
-                }
-                if (currentLatency > this.highLatencyMinThreshold && currentLatency > initialLatency * this.highLatencyMultiple) {
-                    return true;
-                }
-                return false;
-            })()
-        };
-        return this.lastMeasurement;
-    }
-});
-export { IRemoteAgentService, remoteConnectionLatencyMeasurer };

package/vscode/src/vs/workbench/services/remote/common/remoteExplorerService.d.ts

@@ -1,83 +0,0 @@
-import { ServiceIdentifier } from '../../../../platform/instantiation/common/instantiation.js';
-import { Event } from '../../../../base/common/event.js';
-import { IDisposable } from '../../../../base/common/lifecycle.js';
-import { URI } from '../../../../base/common/uri.js';
-import { RemoteTunnel, TunnelProtocol } from '../../../../platform/tunnel/common/tunnel.js';
-import { IEditableData } from '../../../common/views.js';
-import { TunnelInformation, TunnelPrivacy } from '../../../../platform/remote/common/remoteAuthorityResolver.js';
-import { TunnelModel, TunnelProperties, Attributes, TunnelCloseReason, CandidatePort, TunnelSource } from './tunnelModel.js';
-import { IExtensionPointUser } from '../../extensions/common/extensionsRegistry.js';
-import { IExtensionDescription } from '../../../../platform/extensions/common/extensions.js';
-
-declare enum TunnelType {
-    Candidate = "Candidate",
-    Detected = "Detected",
-    Forwarded = "Forwarded",
-    Add = "Add"
-}
-interface ITunnelItem {
-    tunnelType: TunnelType;
-    remoteHost: string;
-    remotePort: number;
-    localAddress?: string;
-    protocol: TunnelProtocol;
-    localUri?: URI;
-    localPort?: number;
-    name?: string;
-    closeable?: boolean;
-    source: {
-        source: TunnelSource;
-        description: string;
-    };
-    privacy: TunnelPrivacy;
-    processDescription?: string;
-    readonly label: string;
-}
-declare enum TunnelEditId {
-    None = 0,
-    New = 1,
-    Label = 2,
-    LocalPort = 3
-}
-interface HelpInformation {
-    extensionDescription: IExtensionDescription;
-    getStarted?: string | {
-        id: string;
-    };
-    documentation?: string;
-    issues?: string;
-    reportIssue?: string;
-    remoteName?: string[] | string;
-    virtualWorkspace?: string;
-}
-
-declare const IRemoteExplorerService: ServiceIdentifier<IRemoteExplorerService>;
-interface IRemoteExplorerService {
-    readonly _serviceBrand: undefined;
-    onDidChangeTargetType: Event<string[]>;
-    targetType: string[];
-    onDidChangeHelpInformation: Event<readonly IExtensionPointUser<HelpInformation>[]>;
-    helpInformation: IExtensionPointUser<HelpInformation>[];
-    readonly tunnelModel: TunnelModel;
-    onDidChangeEditable: Event<{
-        tunnel: ITunnelItem;
-        editId: TunnelEditId;
-    } | undefined>;
-    setEditable(tunnelItem: ITunnelItem | undefined, editId: TunnelEditId, data: IEditableData | null): void;
-    getEditableData(tunnelItem: ITunnelItem | undefined, editId?: TunnelEditId): IEditableData | undefined;
-    forward(tunnelProperties: TunnelProperties, attributes?: Attributes | null): Promise<RemoteTunnel | string | undefined>;
-    close(remote: {
-        host: string;
-        port: number;
-    }, reason: TunnelCloseReason): Promise<void>;
-    setTunnelInformation(tunnelInformation: TunnelInformation | undefined): void;
-    setCandidateFilter(filter: ((candidates: CandidatePort[]) => Promise<CandidatePort[]>) | undefined): IDisposable;
-    onFoundNewCandidates(candidates: CandidatePort[]): void;
-    restore(): Promise<void>;
-    enablePortsFeatures(): void;
-    onEnabledPortsFeatures: Event<void>;
-    portsFeaturesEnabled: boolean;
-    readonly namedProcesses: Map<number, string>;
-}
-
-export { type HelpInformation, IRemoteExplorerService, type ITunnelItem, TunnelEditId, TunnelType };