@codingame/monaco-vscode-extensions-service-override 1.82.4 → 1.82.5-next.1

package/dist/main/vscode/src/vs/workbench/api/common/extHost.api.impl.d.ts

@@ -0,0 +1,14 @@
+import { ExtHostConfigProvider } from './extHostConfiguration.js';
+import { ExtensionDescriptionRegistry } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionDescriptionRegistry';
+import * as vscodeProposed_d from '../../../../../../../../vscode-proposed.js';
+import { IExtensionDescription } from 'vscode/vscode/vs/platform/extensions/common/extensions';
+
+interface IExtensionRegistries {
+    mine: ExtensionDescriptionRegistry;
+    all: ExtensionDescriptionRegistry;
+}
+interface IExtensionApiFactory {
+    (extension: IExtensionDescription, extensionInfo: IExtensionRegistries, configProvider: ExtHostConfigProvider): typeof vscodeProposed_d;
+}
+
+export type { IExtensionApiFactory, IExtensionRegistries };

package/dist/main/vscode/src/vs/workbench/api/common/extHost.protocol.d.ts

@@ -0,0 +1,236 @@
+import { Dto } from 'vscode/vscode/vs/workbench/services/extensions/common/proxyIdentifier';
+import { VSBuffer } from 'vscode/vscode/vs/base/common/buffer';
+import { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
+import { UriComponents, URI } from 'vscode/vscode/vs/base/common/uri';
+import { SerializedError } from 'vscode/vscode/vs/base/common/errors';
+import { IDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { PerformanceMark } from 'vscode/vscode/vs/base/common/performance';
+import { Command } from 'vscode/vscode/vs/editor/common/languages';
+import { IConfigurationData, ConfigurationTarget, IConfigurationOverrides, IConfigurationChange } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { ConfigurationScope } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
+import { IExtensionDescription, ExtensionIdentifier } from 'vscode/vscode/vs/platform/extensions/common/extensions';
+import { IRemoteConnectionData } from 'vscode/vscode/vs/platform/remote/common/remoteAuthorityResolver';
+import { ClassifiedEvent, OmitMetadata, IGDPRProperty, StrictPropertyCheck } from 'vscode/vscode/vs/platform/telemetry/common/gdprTypings';
+import { ISerializableEnvironmentVariableCollection } from 'vscode/vscode/vs/platform/terminal/common/environmentVariable';
+import { TerminalExitReason, IShellLaunchConfigDto, ITerminalLaunchError, ITerminalProfile, ICreateContributedTerminalProfileOptions } from 'vscode/vscode/vs/platform/terminal/common/terminal';
+import { TunnelOptions, TunnelCreationOptions, ProvidedPortAttributes, TunnelPrivacyId } from 'vscode/vscode/vs/platform/tunnel/common/tunnel';
+import { EditSessionIdentityMatch } from 'vscode/vscode/vs/platform/workspace/common/editSessions';
+import { WorkspaceTrustRequestOptions } from 'vscode/vscode/vs/platform/workspace/common/workspaceTrust';
+import { ExtensionActivationReason, MissingExtensionDependency, ActivationKind } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+import { IPatternInfo, IRawFileMatch2 } from 'vscode/vscode/vs/workbench/services/search/common/search';
+import { IExtensionDescriptionDelta, IStaticWorkspaceData } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionHostProtocol';
+import { IResolveAuthorityResult } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionHostProxy';
+import { CandidatePort } from 'vscode/vscode/vs/workbench/services/remote/common/tunnelModel';
+import { ITextQueryBuilderOptions } from '../../services/search/common/queryBuilder.js';
+
+interface IWorkspaceData extends IStaticWorkspaceData {
+    folders: {
+        uri: UriComponents;
+        name: string;
+        index: number;
+    }[];
+}
+interface IConfigurationInitData extends IConfigurationData {
+    configurationScopes: [string, ConfigurationScope | undefined][];
+}
+interface MainThreadConfigurationShape extends IDisposable {
+    $updateConfigurationOption(target: ConfigurationTarget | null, key: string, value: any, overrides: IConfigurationOverrides | undefined, scopeToLanguage: boolean | undefined): Promise<void>;
+    $removeConfigurationOption(target: ConfigurationTarget | null, key: string, overrides: IConfigurationOverrides | undefined, scopeToLanguage: boolean | undefined): Promise<void>;
+}
+/**
+ * A terminal that is created on the extension host side is temporarily assigned
+ * a UUID by the extension host that created it. Once the renderer side has assigned
+ * a real numeric id, the numeric id will be used.
+ *
+ * All other terminals (that are not created on the extension host side) always
+ * use the numeric id.
+ */
+type ExtHostTerminalIdentifier = number | string;
+interface MainThreadTelemetryShape extends IDisposable {
+    $publicLog(eventName: string, data?: any): void;
+    $publicLog2<E extends ClassifiedEvent<OmitMetadata<T>> = never, T extends IGDPRProperty = never>(eventName: string, data?: StrictPropertyCheck<T, E>): void;
+}
+interface ExtHostManagedSocketsShape {
+    $openRemoteSocket(socketFactoryId: number): Promise<number>;
+    $remoteSocketWrite(socketId: number, buffer: VSBuffer): void;
+    $remoteSocketEnd(socketId: number): void;
+    $remoteSocketDrain(socketId: number): Promise<void>;
+}
+interface ITextSearchComplete {
+    limitHit?: boolean;
+}
+interface MainThreadWorkspaceShape extends IDisposable {
+    $startFileSearch(includePattern: string | null, includeFolder: UriComponents | null, excludePatternOrDisregardExcludes: string | false | null, maxResults: number | null, token: CancellationToken): Promise<UriComponents[] | null>;
+    $startTextSearch(query: IPatternInfo, folder: UriComponents | null, options: ITextQueryBuilderOptions, requestId: number, token: CancellationToken): Promise<ITextSearchComplete | null>;
+    $checkExists(folders: readonly UriComponents[], includes: string[], token: CancellationToken): Promise<boolean>;
+    $save(uri: UriComponents, options: {
+        saveAs: boolean;
+    }): Promise<UriComponents | undefined>;
+    $saveAll(includeUntitled?: boolean): Promise<boolean>;
+    $updateWorkspaceFolders(extensionName: string, index: number, deleteCount: number, workspaceFoldersToAdd: {
+        uri: UriComponents;
+        name?: string;
+    }[]): Promise<void>;
+    $resolveProxy(url: string): Promise<string | undefined>;
+    $requestWorkspaceTrust(options?: WorkspaceTrustRequestOptions): Promise<boolean | undefined>;
+    $registerEditSessionIdentityProvider(handle: number, scheme: string): void;
+    $unregisterEditSessionIdentityProvider(handle: number): void;
+    $registerCanonicalUriProvider(handle: number, scheme: string): void;
+    $unregisterCanonicalUriProvider(handle: number): void;
+}
+interface MainThreadExtensionServiceShape extends IDisposable {
+    $getExtension(extensionId: string): Promise<Dto<IExtensionDescription> | undefined>;
+    $activateExtension(extensionId: ExtensionIdentifier, reason: ExtensionActivationReason): Promise<void>;
+    $onWillActivateExtension(extensionId: ExtensionIdentifier): Promise<void>;
+    $onDidActivateExtension(extensionId: ExtensionIdentifier, codeLoadingTime: number, activateCallTime: number, activateResolvedTime: number, activationReason: ExtensionActivationReason): void;
+    $onExtensionActivationError(extensionId: ExtensionIdentifier, error: SerializedError, missingExtensionDependency: MissingExtensionDependency | null): Promise<void>;
+    $onExtensionRuntimeError(extensionId: ExtensionIdentifier, error: SerializedError): void;
+    $setPerformanceMarks(marks: PerformanceMark[]): Promise<void>;
+    $asBrowserUri(uri: UriComponents): Promise<UriComponents>;
+    $getAllStaticBrowserUris(): Promise<[UriComponents, UriComponents][]>;
+}
+interface PortAttributesSelector {
+    portRange?: [number, number] | number;
+    commandPattern?: RegExp;
+}
+interface ExtHostConfigurationShape {
+    $initializeConfiguration(data: IConfigurationInitData): void;
+    $acceptConfigurationChanged(data: IConfigurationInitData, change: IConfigurationChange): void;
+}
+interface ExtHostWorkspaceShape {
+    $initializeWorkspace(workspace: IWorkspaceData | null, trusted: boolean): void;
+    $acceptWorkspaceData(workspace: IWorkspaceData | null): void;
+    $handleTextSearchResult(result: IRawFileMatch2, requestId: number): void;
+    $onDidGrantWorkspaceTrust(): void;
+    $getEditSessionIdentifier(folder: UriComponents, token: CancellationToken): Promise<string | undefined>;
+    $provideEditSessionIdentityMatch(folder: UriComponents, identity1: string, identity2: string, token: CancellationToken): Promise<EditSessionIdentityMatch | undefined>;
+    $onWillCreateEditSessionIdentity(folder: UriComponents, token: CancellationToken, timeout: number): Promise<void>;
+    $provideCanonicalUri(uri: UriComponents, targetScheme: string, token: CancellationToken): Promise<UriComponents | undefined>;
+}
+interface ExtHostFileSystemInfoShape {
+    $acceptProviderInfos(uri: UriComponents, capabilities: number | null): void;
+}
+interface ExtHostExtensionServiceShape {
+    $resolveAuthority(remoteAuthority: string, resolveAttempt: number): Promise<Dto<IResolveAuthorityResult>>;
+    /**
+     * Returns `null` if no resolver for `remoteAuthority` is found.
+     */
+    $getCanonicalURI(remoteAuthority: string, uri: UriComponents): Promise<UriComponents | null>;
+    $startExtensionHost(extensionsDelta: IExtensionDescriptionDelta): Promise<void>;
+    $extensionTestsExecute(): Promise<number>;
+    $activateByEvent(activationEvent: string, activationKind: ActivationKind): Promise<void>;
+    $activate(extensionId: ExtensionIdentifier, reason: ExtensionActivationReason): Promise<boolean>;
+    $setRemoteEnvironment(env: {
+        [key: string]: string | null;
+    }): Promise<void>;
+    $updateRemoteConnectionData(connectionData: IRemoteConnectionData): Promise<void>;
+    $deltaExtensions(extensionsDelta: IExtensionDescriptionDelta): Promise<void>;
+    $test_latency(n: number): Promise<number>;
+    $test_up(b: VSBuffer): Promise<number>;
+    $test_down(size: number): Promise<VSBuffer>;
+}
+type ICommandDto = {
+    $ident?: string;
+} & Command;
+interface ITerminalLinkDto {
+    /** The ID of the link to enable activation and disposal. */
+    id: number;
+    /** The startIndex of the link in the line. */
+    startIndex: number;
+    /** The length of the link in the line. */
+    length: number;
+    /** The descriptive label for what the link does when activated. */
+    label?: string;
+}
+interface ITerminalDimensionsDto {
+    columns: number;
+    rows: number;
+}
+type SingleOrMany<T> = T[] | T;
+interface ITerminalQuickFixExecuteTerminalCommandDto {
+    terminalCommand: string;
+}
+interface ITerminalQuickFixOpenerDto {
+    uri: UriComponents;
+}
+type TerminalQuickFix = ITerminalQuickFixExecuteTerminalCommandDto | ITerminalQuickFixOpenerDto | ICommandDto;
+interface TerminalCommandMatchResultDto {
+    commandLine: string;
+    commandLineMatch: RegExpMatchArray;
+    outputMatch?: {
+        regexMatch: RegExpMatchArray;
+        outputLines: string[];
+    };
+}
+interface ITerminalCommandDto {
+    commandLine: string | undefined;
+    cwd: URI | string | undefined;
+    exitCode: number | undefined;
+    output: string | undefined;
+}
+interface ExtHostTerminalServiceShape {
+    $acceptTerminalClosed(id: number, exitCode: number | undefined, exitReason: TerminalExitReason): void;
+    $acceptTerminalOpened(id: number, extHostTerminalId: string | undefined, name: string, shellLaunchConfig: IShellLaunchConfigDto): void;
+    $acceptActiveTerminalChanged(id: number | null): void;
+    $acceptTerminalProcessId(id: number, processId: number): void;
+    $acceptTerminalProcessData(id: number, data: string): void;
+    $acceptDidExecuteCommand(id: number, command: ITerminalCommandDto): void;
+    $acceptTerminalTitleChange(id: number, name: string): void;
+    $acceptTerminalDimensions(id: number, cols: number, rows: number): void;
+    $acceptTerminalMaximumDimensions(id: number, cols: number, rows: number): void;
+    $acceptTerminalInteraction(id: number): void;
+    $acceptTerminalSelection(id: number, selection: string | undefined): void;
+    $startExtensionTerminal(id: number, initialDimensions: ITerminalDimensionsDto | undefined): Promise<ITerminalLaunchError | undefined>;
+    $acceptProcessAckDataEvent(id: number, charCount: number): void;
+    $acceptProcessInput(id: number, data: string): void;
+    $acceptProcessResize(id: number, cols: number, rows: number): void;
+    $acceptProcessShutdown(id: number, immediate: boolean): void;
+    $acceptProcessRequestInitialCwd(id: number): void;
+    $acceptProcessRequestCwd(id: number): void;
+    $acceptProcessRequestLatency(id: number): Promise<number>;
+    $provideLinks(id: number, line: string): Promise<ITerminalLinkDto[]>;
+    $activateLink(id: number, linkId: number): void;
+    $initEnvironmentVariableCollections(collections: [string, ISerializableEnvironmentVariableCollection][]): void;
+    $acceptDefaultProfile(profile: ITerminalProfile, automationProfile: ITerminalProfile): void;
+    $createContributedProfileTerminal(id: string, options: ICreateContributedTerminalProfileOptions): Promise<void>;
+    $provideTerminalQuickFixes(id: string, matchResult: TerminalCommandMatchResultDto, token: CancellationToken): Promise<SingleOrMany<TerminalQuickFix> | undefined>;
+}
+interface TunnelDto {
+    remoteAddress: {
+        port: number;
+        host: string;
+    };
+    localAddress: {
+        port: number;
+        host: string;
+    } | string;
+    public: boolean;
+    privacy: TunnelPrivacyId | string;
+    protocol: string | undefined;
+}
+interface ExtHostTunnelServiceShape {
+    $forwardPort(tunnelOptions: TunnelOptions, tunnelCreationOptions: TunnelCreationOptions): Promise<TunnelDto | string | undefined>;
+    $closeTunnel(remote: {
+        host: string;
+        port: number;
+    }, silent?: boolean): Promise<void>;
+    $onDidTunnelsChange(): Promise<void>;
+    $registerCandidateFinder(enable: boolean): Promise<void>;
+    $applyCandidateFilter(candidates: CandidatePort[]): Promise<CandidatePort[]>;
+    $providePortAttributes(handles: number[], ports: number[], pid: number | undefined, commandline: string | undefined, cancellationToken: CancellationToken): Promise<ProvidedPortAttributes[]>;
+}
+interface ExtHostLocalizationShape {
+    getMessage(extensionId: string, details: IStringDetails): string;
+    getBundle(extensionId: string): {
+        [key: string]: string;
+    } | undefined;
+    getBundleUri(extensionId: string): URI | undefined;
+    initializeLocalizedMessages(extension: IExtensionDescription): Promise<void>;
+}
+interface IStringDetails {
+    message: string;
+    args?: Record<string | number, any>;
+    comment?: string | string[];
+}
+
+export type { ExtHostConfigurationShape, ExtHostExtensionServiceShape, ExtHostFileSystemInfoShape, ExtHostLocalizationShape, ExtHostManagedSocketsShape, ExtHostTerminalIdentifier, ExtHostTerminalServiceShape, ExtHostTunnelServiceShape, ExtHostWorkspaceShape, ICommandDto, IConfigurationInitData, IStringDetails, ITerminalCommandDto, ITerminalDimensionsDto, ITerminalLinkDto, ITerminalQuickFixExecuteTerminalCommandDto, ITerminalQuickFixOpenerDto, ITextSearchComplete, IWorkspaceData, MainThreadConfigurationShape, MainThreadExtensionServiceShape, MainThreadTelemetryShape, MainThreadWorkspaceShape, PortAttributesSelector, TerminalCommandMatchResultDto, TerminalQuickFix, TunnelDto };

package/dist/main/vscode/src/vs/workbench/api/common/extHostConfiguration.d.ts

@@ -0,0 +1,43 @@
+import { ServiceIdentifier } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { Event } from 'vscode/vscode/vs/base/common/event';
+import { ConfigurationChangeEvent, ConfigurationScope, WorkspaceConfiguration } from 'vscode';
+import { IExtHostWorkspace, ExtHostWorkspace } from './extHostWorkspace.js';
+import { ExtHostConfigurationShape, IConfigurationInitData, MainThreadConfigurationShape } from './extHost.protocol.js';
+import { IConfigurationChange } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { IExtensionDescription } from 'vscode/vscode/vs/platform/extensions/common/extensions';
+import { IExtHostRpcService } from './extHostRpcService.js';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
+
+declare class ExtHostConfiguration implements ExtHostConfigurationShape {
+    readonly _serviceBrand: undefined;
+    private readonly _proxy;
+    private readonly _logService;
+    private readonly _extHostWorkspace;
+    private readonly _barrier;
+    private _actual;
+    constructor(extHostRpc: IExtHostRpcService, extHostWorkspace: IExtHostWorkspace, logService: ILogService);
+    getConfigProvider(): Promise<ExtHostConfigProvider>;
+    $initializeConfiguration(data: IConfigurationInitData): void;
+    $acceptConfigurationChanged(data: IConfigurationInitData, change: IConfigurationChange): void;
+}
+declare class ExtHostConfigProvider {
+    private readonly _onDidChangeConfiguration;
+    private readonly _proxy;
+    private readonly _extHostWorkspace;
+    private _configurationScopes;
+    private _configuration;
+    private _logService;
+    constructor(proxy: MainThreadConfigurationShape, extHostWorkspace: ExtHostWorkspace, data: IConfigurationInitData, logService: ILogService);
+    get onDidChangeConfiguration(): Event<ConfigurationChangeEvent>;
+    $acceptConfigurationChanged(data: IConfigurationInitData, change: IConfigurationChange): void;
+    getConfiguration(section?: string, scope?: ConfigurationScope | null, extensionDescription?: IExtensionDescription): WorkspaceConfiguration;
+    private _toReadonlyValue;
+    private _validateConfigurationAccess;
+    private _toConfigurationChangeEvent;
+    private _toMap;
+}
+declare const IExtHostConfiguration: ServiceIdentifier<IExtHostConfiguration>;
+interface IExtHostConfiguration extends ExtHostConfiguration {
+}
+
+export { ExtHostConfigProvider, ExtHostConfiguration, IExtHostConfiguration };

package/dist/main/vscode/src/vs/workbench/api/common/extHostExtensionActivator.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Represents the API of an extension (return value of `activate`).
+ */
+interface IExtensionAPI {
+}
+declare class ExtensionActivationTimes {
+    static readonly NONE: ExtensionActivationTimes;
+    readonly startup: boolean;
+    readonly codeLoadingTime: number;
+    readonly activateCallTime: number;
+    readonly activateResolvedTime: number;
+    constructor(startup: boolean, codeLoadingTime: number, activateCallTime: number, activateResolvedTime: number);
+}
+declare class ExtensionActivationTimesBuilder {
+    private readonly _startup;
+    private _codeLoadingStart;
+    private _codeLoadingStop;
+    private _activateCallStart;
+    private _activateCallStop;
+    private _activateResolveStart;
+    private _activateResolveStop;
+    constructor(startup: boolean);
+    private _delta;
+    build(): ExtensionActivationTimes;
+    codeLoadingStart(): void;
+    codeLoadingStop(): void;
+    activateCallStart(): void;
+    activateCallStop(): void;
+    activateResolveStart(): void;
+    activateResolveStop(): void;
+}
+
+export { ExtensionActivationTimes, ExtensionActivationTimesBuilder, type IExtensionAPI };

package/dist/main/vscode/src/vs/workbench/api/common/extHostExtensionService.d.ts

@@ -0,0 +1,139 @@
+import { IInstantiationService, ServiceIdentifier } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { TernarySearchTree } from 'vscode/vscode/vs/base/common/ternarySearchTree';
+import { UriComponents, URI } from 'vscode/vscode/vs/base/common/uri';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
+import { ExtHostExtensionServiceShape, MainThreadWorkspaceShape, MainThreadTelemetryShape, MainThreadExtensionServiceShape } from './extHost.protocol.js';
+import { IExtensionHostInitData, IExtensionDescriptionDelta } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionHostProtocol';
+import { ExtHostConfiguration, IExtHostConfiguration } from './extHostConfiguration.js';
+import { IExtensionAPI, ExtensionActivationTimesBuilder } from './extHostExtensionActivator.js';
+import { ExtHostWorkspace, IExtHostWorkspace } from './extHostWorkspace.js';
+import { ExtensionActivationReason, ActivationKind } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+import { ExtensionDescriptionRegistry } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionDescriptionRegistry';
+import { RemoteAuthorityResolver, ExecServer } from '../../../../../../../../vscode-proposed.js';
+import { ExtensionIdentifier, IExtensionDescription } from 'vscode/vscode/vs/platform/extensions/common/extensions';
+import { VSBuffer } from 'vscode/vscode/vs/base/common/buffer';
+import { ExtensionRuntime } from './extHostTypes.js';
+import { IRemoteConnectionData } from 'vscode/vscode/vs/platform/remote/common/remoteAuthorityResolver';
+import { IExtHostInitDataService } from './extHostInitDataService.js';
+import { IExtensionStoragePaths } from './extHostStoragePaths.js';
+import { IExtHostRpcService } from './extHostRpcService.js';
+import { IExtHostTunnelService } from './extHostTunnelService.js';
+import { IExtHostTerminalService } from './extHostTerminalService.js';
+import { Event } from 'vscode/vscode/vs/base/common/event';
+import { IResolveAuthorityResult } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionHostProxy';
+import { IExtHostLocalizationService } from './extHostLocalizationService.js';
+import { IExtHostManagedSockets } from './extHostManagedSockets.js';
+import { Dto } from 'vscode/vscode/vs/workbench/services/extensions/common/proxyIdentifier';
+import { Disposable as Disposable$1 } from 'vscode';
+
+declare const IHostUtils: ServiceIdentifier<IHostUtils>;
+interface IHostUtils {
+    readonly _serviceBrand: undefined;
+    readonly pid: number | undefined;
+    exit(code: number): void;
+    fsExists?(path: string): Promise<boolean>;
+    fsRealpath?(path: string): Promise<string>;
+}
+declare abstract class AbstractExtHostExtensionService extends Disposable implements ExtHostExtensionServiceShape {
+    private readonly _extHostManagedSockets;
+    readonly _serviceBrand: undefined;
+    abstract readonly extensionRuntime: ExtensionRuntime;
+    private readonly _onDidChangeRemoteConnectionData;
+    readonly onDidChangeRemoteConnectionData: Event<void>;
+    protected readonly _hostUtils: IHostUtils;
+    protected readonly _initData: IExtensionHostInitData;
+    protected readonly _extHostContext: IExtHostRpcService;
+    protected readonly _instaService: IInstantiationService;
+    protected readonly _extHostWorkspace: ExtHostWorkspace;
+    protected readonly _extHostConfiguration: ExtHostConfiguration;
+    protected readonly _logService: ILogService;
+    protected readonly _extHostTunnelService: IExtHostTunnelService;
+    protected readonly _extHostTerminalService: IExtHostTerminalService;
+    protected readonly _extHostLocalizationService: IExtHostLocalizationService;
+    protected readonly _mainThreadWorkspaceProxy: MainThreadWorkspaceShape;
+    protected readonly _mainThreadTelemetryProxy: MainThreadTelemetryShape;
+    protected readonly _mainThreadExtensionsProxy: MainThreadExtensionServiceShape;
+    private readonly _almostReadyToRunExtensions;
+    private readonly _readyToStartExtensionHost;
+    private readonly _readyToRunExtensions;
+    private readonly _eagerExtensionsActivated;
+    private readonly _activationEventsReader;
+    protected readonly _myRegistry: ExtensionDescriptionRegistry;
+    protected readonly _globalRegistry: ExtensionDescriptionRegistry;
+    private readonly _storage;
+    private readonly _secretState;
+    private readonly _storagePath;
+    private readonly _activator;
+    private _extensionPathIndex;
+    private readonly _resolvers;
+    private _started;
+    private _isTerminating;
+    private _remoteConnectionData;
+    constructor(instaService: IInstantiationService, hostUtils: IHostUtils, extHostContext: IExtHostRpcService, extHostWorkspace: IExtHostWorkspace, extHostConfiguration: IExtHostConfiguration, logService: ILogService, initData: IExtHostInitDataService, storagePath: IExtensionStoragePaths, extHostTunnelService: IExtHostTunnelService, extHostTerminalService: IExtHostTerminalService, extHostLocalizationService: IExtHostLocalizationService, _extHostManagedSockets: IExtHostManagedSockets);
+    getRemoteConnectionData(): IRemoteConnectionData | null;
+    initialize(): Promise<void>;
+    private _deactivateAll;
+    terminate(reason: string, code?: number): void;
+    isActivated(extensionId: ExtensionIdentifier): boolean;
+    getExtension(extensionId: string): Promise<IExtensionDescription | undefined>;
+    private _activateByEvent;
+    private _activateById;
+    activateByIdWithErrors(extensionId: ExtensionIdentifier, reason: ExtensionActivationReason): Promise<void>;
+    getExtensionRegistry(): Promise<ExtensionDescriptionRegistry>;
+    getExtensionExports(extensionId: ExtensionIdentifier): IExtensionAPI | null | undefined;
+    /**
+     * Applies realpath to file-uris and returns all others uris unmodified
+     */
+    private _realPathExtensionUri;
+    getExtensionPathIndex(): Promise<ExtensionPaths>;
+    /**
+     * create trie to enable fast 'filename -> extension id' look up
+     */
+    private _createExtensionPathIndex;
+    private _deactivate;
+    private _activateExtension;
+    private _logExtensionActivationTimes;
+    private _doActivateExtension;
+    private _loadExtensionContext;
+    private static _callActivate;
+    private static _callActivateOptional;
+    private _activateOneStartupFinished;
+    private _activateAllStartupFinishedDeferred;
+    private _activateAllStartupFinished;
+    private _handleEagerExtensions;
+    private _handleWorkspaceContainsEagerExtensions;
+    private _handleWorkspaceContainsEagerExtension;
+    private _handleRemoteResolverEagerExtensions;
+    $extensionTestsExecute(): Promise<number>;
+    private _doHandleExtensionTests;
+    private _startExtensionHost;
+    registerRemoteAuthorityResolver(authorityPrefix: string, resolver: RemoteAuthorityResolver): Disposable$1;
+    getRemoteExecServer(remoteAuthority: string): Promise<ExecServer | undefined>;
+    private _activateAndGetResolver;
+    $resolveAuthority(remoteAuthorityChain: string, resolveAttempt: number): Promise<Dto<IResolveAuthorityResult>>;
+    $getCanonicalURI(remoteAuthority: string, uriComponents: UriComponents): Promise<UriComponents | null>;
+    $startExtensionHost(extensionsDelta: IExtensionDescriptionDelta): Promise<void>;
+    $activateByEvent(activationEvent: string, activationKind: ActivationKind): Promise<void>;
+    $activate(extensionId: ExtensionIdentifier, reason: ExtensionActivationReason): Promise<boolean>;
+    $deltaExtensions(extensionsDelta: IExtensionDescriptionDelta): Promise<void>;
+    $test_latency(n: number): Promise<number>;
+    $test_up(b: VSBuffer): Promise<number>;
+    $test_down(size: number): Promise<VSBuffer>;
+    $updateRemoteConnectionData(connectionData: IRemoteConnectionData): Promise<void>;
+    protected abstract _beforeAlmostReadyToRunExtensions(): Promise<void>;
+    protected abstract _getEntryPoint(extensionDescription: IExtensionDescription): string | undefined;
+    protected abstract _loadCommonJSModule<T extends object | undefined>(extensionId: IExtensionDescription | null, module: URI, activationTimesBuilder: ExtensionActivationTimesBuilder): Promise<T>;
+    abstract $setRemoteEnvironment(env: {
+        [key: string]: string | null;
+    }): Promise<void>;
+}
+declare class ExtensionPaths {
+    private _searchTree;
+    constructor(_searchTree: TernarySearchTree<URI, IExtensionDescription>);
+    setSearchTree(searchTree: TernarySearchTree<URI, IExtensionDescription>): void;
+    findSubstr(key: URI): IExtensionDescription | undefined;
+    forEach(callback: (value: IExtensionDescription, index: URI) => any): void;
+}
+
+export { AbstractExtHostExtensionService, ExtensionPaths, IHostUtils };

package/dist/main/vscode/src/vs/workbench/api/common/extHostFileSystemInfo.d.ts

@@ -0,0 +1,21 @@
+import { ServiceIdentifier } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { IExtUri } from 'vscode/vscode/vs/base/common/resources';
+import { UriComponents } from 'vscode/vscode/vs/base/common/uri';
+import { ExtHostFileSystemInfoShape } from './extHost.protocol.js';
+
+declare class ExtHostFileSystemInfo implements ExtHostFileSystemInfoShape {
+    readonly _serviceBrand: undefined;
+    private readonly _systemSchemes;
+    private readonly _providerInfo;
+    readonly extUri: IExtUri;
+    constructor();
+    $acceptProviderInfos(uri: UriComponents, capabilities: number | null): void;
+    isFreeScheme(scheme: string): boolean;
+    getCapabilities(scheme: string): number | undefined;
+}
+interface IExtHostFileSystemInfo extends ExtHostFileSystemInfo {
+    readonly extUri: IExtUri;
+}
+declare const IExtHostFileSystemInfo: ServiceIdentifier<IExtHostFileSystemInfo>;
+
+export { ExtHostFileSystemInfo, IExtHostFileSystemInfo };

package/dist/main/vscode/src/vs/workbench/api/common/extHostInitDataService.d.ts

@@ -0,0 +1,9 @@
+import { ServiceIdentifier } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { IExtensionHostInitData } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionHostProtocol';
+
+declare const IExtHostInitDataService: ServiceIdentifier<IExtHostInitDataService>;
+interface IExtHostInitDataService extends Readonly<IExtensionHostInitData> {
+    readonly _serviceBrand: undefined;
+}
+
+export { IExtHostInitDataService };

package/dist/main/vscode/src/vs/workbench/api/common/extHostLocalizationService.d.ts

@@ -0,0 +1,29 @@
+import { ServiceIdentifier } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { IExtensionDescription } from 'vscode/vscode/vs/platform/extensions/common/extensions';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
+import { ExtHostLocalizationShape, IStringDetails } from './extHost.protocol.js';
+import { IExtHostInitDataService } from './extHostInitDataService.js';
+import { IExtHostRpcService } from './extHostRpcService.js';
+
+declare class ExtHostLocalizationService implements ExtHostLocalizationShape {
+    private readonly logService;
+    readonly _serviceBrand: undefined;
+    private readonly _proxy;
+    private readonly currentLanguage;
+    private readonly isDefaultLanguage;
+    private readonly bundleCache;
+    constructor(initData: IExtHostInitDataService, rpc: IExtHostRpcService, logService: ILogService);
+    getMessage(extensionId: string, details: IStringDetails): string;
+    getBundle(extensionId: string): {
+        [key: string]: string;
+    } | undefined;
+    getBundleUri(extensionId: string): URI | undefined;
+    initializeLocalizedMessages(extension: IExtensionDescription): Promise<void>;
+    private getBundleLocation;
+}
+declare const IExtHostLocalizationService: ServiceIdentifier<IExtHostLocalizationService>;
+interface IExtHostLocalizationService extends ExtHostLocalizationService {
+}
+
+export { ExtHostLocalizationService, IExtHostLocalizationService };

package/dist/main/vscode/src/vs/workbench/api/common/extHostManagedSockets.d.ts

@@ -0,0 +1,11 @@
+import { ServiceIdentifier } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { ExtHostManagedSocketsShape } from './extHost.protocol.js';
+import { ManagedMessagePassing } from '../../../../../../../../vscode-proposed.js';
+
+interface IExtHostManagedSockets extends ExtHostManagedSocketsShape {
+    setFactory(socketFactoryId: number, makeConnection: () => Thenable<ManagedMessagePassing>): void;
+    readonly _serviceBrand: undefined;
+}
+declare const IExtHostManagedSockets: ServiceIdentifier<IExtHostManagedSockets>;
+
+export { IExtHostManagedSockets };

package/dist/main/vscode/src/vs/workbench/api/common/extHostRpcService.d.ts

@@ -0,0 +1,9 @@
+import { ServiceIdentifier } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { IRPCProtocol } from 'vscode/vscode/vs/workbench/services/extensions/common/proxyIdentifier';
+
+declare const IExtHostRpcService: ServiceIdentifier<IExtHostRpcService>;
+interface IExtHostRpcService extends IRPCProtocol {
+    readonly _serviceBrand: undefined;
+}
+
+export { IExtHostRpcService };

package/dist/main/vscode/src/vs/workbench/api/common/extHostStoragePaths.d.ts

@@ -0,0 +1,14 @@
+import { ServiceIdentifier } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { IExtensionDescription } from 'vscode/vscode/vs/platform/extensions/common/extensions';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+
+declare const IExtensionStoragePaths: ServiceIdentifier<IExtensionStoragePaths>;
+interface IExtensionStoragePaths {
+    readonly _serviceBrand: undefined;
+    whenReady: Promise<any>;
+    workspaceValue(extension: IExtensionDescription): URI | undefined;
+    globalValue(extension: IExtensionDescription): URI;
+    onWillDeactivateAll(): void;
+}
+
+export { IExtensionStoragePaths };

package/dist/main/vscode/src/vs/workbench/api/common/extHostTerminalService.d.ts

@@ -0,0 +1,54 @@
+import { ServiceIdentifier } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { Terminal, TerminalDimensionsChangeEvent, TerminalDataWriteEvent, TerminalExecutedCommand, TerminalQuickFixProvider } from '../../../../../../../../vscode-proposed.js';
+import { Event } from 'vscode/vscode/vs/base/common/event';
+import { ExtHostTerminalServiceShape, ExtHostTerminalIdentifier } from './extHost.protocol.js';
+import { IDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { IExtensionDescription } from 'vscode/vscode/vs/platform/extensions/common/extensions';
+import { TerminalLocation } from 'vscode/vscode/vs/platform/terminal/common/terminal';
+import { TerminalOptions, ExtensionTerminalOptions, Pseudoterminal, TerminalLinkProvider, Disposable, TerminalProfileProvider, EnvironmentVariableCollection, EnvironmentVariableScope } from 'vscode';
+
+interface IEnvironmentVariableCollection extends EnvironmentVariableCollection {
+    getScoped(scope: EnvironmentVariableScope): EnvironmentVariableCollection;
+}
+interface ITerminalInternalOptions {
+    isFeatureTerminal?: boolean;
+    useShellEnvironment?: boolean;
+    resolvedExtHostIdentifier?: ExtHostTerminalIdentifier;
+    /**
+     * This location is different from the API location because it can include splitActiveTerminal,
+     * a property we resolve internally
+     */
+    location?: TerminalLocation | {
+        viewColumn: number;
+        preserveState?: boolean;
+    } | {
+        splitActiveTerminal: boolean;
+    };
+}
+
+interface IExtHostTerminalService extends ExtHostTerminalServiceShape, IDisposable {
+    readonly _serviceBrand: undefined;
+    activeTerminal: Terminal | undefined;
+    terminals: Terminal[];
+    readonly onDidCloseTerminal: Event<Terminal>;
+    readonly onDidOpenTerminal: Event<Terminal>;
+    readonly onDidChangeActiveTerminal: Event<Terminal | undefined>;
+    readonly onDidChangeTerminalDimensions: Event<TerminalDimensionsChangeEvent>;
+    readonly onDidChangeTerminalState: Event<Terminal>;
+    readonly onDidWriteTerminalData: Event<TerminalDataWriteEvent>;
+    readonly onDidExecuteTerminalCommand: Event<TerminalExecutedCommand>;
+    readonly onDidChangeShell: Event<string>;
+    createTerminal(name?: string, shellPath?: string, shellArgs?: readonly string[] | string): Terminal;
+    createTerminalFromOptions(options: TerminalOptions, internalOptions?: ITerminalInternalOptions): Terminal;
+    createExtensionTerminal(options: ExtensionTerminalOptions): Terminal;
+    attachPtyToTerminal(id: number, pty: Pseudoterminal): void;
+    getDefaultShell(useAutomationShell: boolean): string;
+    getDefaultShellArgs(useAutomationShell: boolean): string[] | string;
+    registerLinkProvider(provider: TerminalLinkProvider): Disposable;
+    registerProfileProvider(extension: IExtensionDescription, id: string, provider: TerminalProfileProvider): Disposable;
+    registerTerminalQuickFixProvider(id: string, extensionId: string, provider: TerminalQuickFixProvider): Disposable;
+    getEnvironmentVariableCollection(extension: IExtensionDescription): IEnvironmentVariableCollection;
+}
+declare const IExtHostTerminalService: ServiceIdentifier<IExtHostTerminalService>;
+
+export { IExtHostTerminalService, type ITerminalInternalOptions };