@codingame/monaco-vscode-api 4.5.0 → 4.5.1

package/vscode/src/vs/workbench/services/extensions/common/extensionDescriptionRegistry.d.ts

@@ -0,0 +1,18 @@
+import { IExtensionDescription, ExtensionIdentifier } from '../../../../platform/extensions/common/extensions.js';
+
+interface IReadOnlyExtensionDescriptionRegistry {
+    containsActivationEvent(activationEvent: string): boolean;
+    containsExtension(extensionId: ExtensionIdentifier): boolean;
+    getExtensionDescriptionsForActivationEvent(activationEvent: string): IExtensionDescription[];
+    getAllExtensionDescriptions(): IExtensionDescription[];
+    getExtensionDescription(extensionId: ExtensionIdentifier | string): IExtensionDescription | undefined;
+    getExtensionDescriptionByUUID(uuid: string): IExtensionDescription | undefined;
+    getExtensionDescriptionByIdOrUUID(extensionId: ExtensionIdentifier | string, uuid: string | undefined): IExtensionDescription | undefined;
+}
+declare class ExtensionDescriptionRegistrySnapshot {
+    readonly versionId: number;
+    readonly extensions: readonly IExtensionDescription[];
+    constructor(versionId: number, extensions: readonly IExtensionDescription[]);
+}
+
+export { ExtensionDescriptionRegistrySnapshot, type IReadOnlyExtensionDescriptionRegistry };

package/vscode/src/vs/workbench/services/extensions/common/extensionHostManagers.d.ts

@@ -0,0 +1,39 @@
+import { Event } from '../../../../base/common/event.js';
+import { URI } from '../../../../base/common/uri.js';
+import { ExtensionIdentifier, IExtensionDescription } from '../../../../platform/extensions/common/extensions.js';
+import { ExtensionHostKind } from './extensionHostKind.js';
+import { IExtensionDescriptionDelta } from './extensionHostProtocol.js';
+import { IResolveAuthorityResult } from './extensionHostProxy.js';
+import { ExtensionRunningLocation } from './extensionRunningLocation.js';
+import { ExtensionHostStartup, ExtensionActivationReason, ActivationKind } from './extensions.js';
+import { ResponsiveState } from './rpcProtocol.js';
+
+interface IExtensionHostManager {
+    readonly pid: number | null;
+    readonly kind: ExtensionHostKind;
+    readonly startup: ExtensionHostStartup;
+    readonly friendyName: string;
+    readonly onDidExit: Event<[number, string | null]>;
+    readonly onDidChangeResponsiveState: Event<ResponsiveState>;
+    dispose(): void;
+    ready(): Promise<void>;
+    representsRunningLocation(runningLocation: ExtensionRunningLocation): boolean;
+    deltaExtensions(extensionsDelta: IExtensionDescriptionDelta): Promise<void>;
+    containsExtension(extensionId: ExtensionIdentifier): boolean;
+    activate(extension: ExtensionIdentifier, reason: ExtensionActivationReason): Promise<boolean>;
+    activateByEvent(activationEvent: string, activationKind: ActivationKind): Promise<void>;
+    activationEventIsDone(activationEvent: string): boolean;
+    getInspectPort(tryEnableInspector: boolean): Promise<number>;
+    resolveAuthority(remoteAuthority: string, resolveAttempt: number): Promise<IResolveAuthorityResult>;
+    /**
+     * Returns `null` if no resolver for `remoteAuthority` is found.
+     */
+    getCanonicalURI(remoteAuthority: string, uri: URI): Promise<URI | null>;
+    start(extensionRegistryVersionId: number, allExtensions: readonly IExtensionDescription[], myExtensions: ExtensionIdentifier[]): Promise<void>;
+    extensionTestsExecute(): Promise<number>;
+    setRemoteEnvironment(env: {
+        [key: string]: string | null;
+    }): Promise<void>;
+}
+
+export type { IExtensionHostManager };

package/vscode/src/vs/workbench/services/extensions/common/extensionHostProxy.d.ts

@@ -0,0 +1,17 @@
+import { RemoteAuthorityResolverErrorCode, ResolverResult } from '../../../../platform/remote/common/remoteAuthorityResolver.js';
+
+interface IResolveAuthorityErrorResult {
+    type: 'error';
+    error: {
+        message: string | undefined;
+        code: RemoteAuthorityResolverErrorCode;
+        detail: any;
+    };
+}
+interface IResolveAuthorityOKResult {
+    type: 'ok';
+    value: ResolverResult;
+}
+type IResolveAuthorityResult = IResolveAuthorityErrorResult | IResolveAuthorityOKResult;
+
+export type { IResolveAuthorityErrorResult, IResolveAuthorityOKResult, IResolveAuthorityResult };

package/vscode/src/vs/workbench/services/extensions/common/extensionManifestPropertiesService.service.d.ts

@@ -0,0 +1,20 @@
+import { ServiceIdentifier } from '../../../../platform/instantiation/common/instantiation.js';
+import { IExtensionManifest, IExtensionIdentifier, ExtensionUntrustedWorkspaceSupportType, ExtensionVirtualWorkspaceSupportType } from '../../../../platform/extensions/common/extensions.js';
+import { ExtensionKind } from '../../../../platform/environment/common/environment.js';
+
+declare const IExtensionManifestPropertiesService: ServiceIdentifier<IExtensionManifestPropertiesService>;
+interface IExtensionManifestPropertiesService {
+    readonly _serviceBrand: undefined;
+    prefersExecuteOnUI(manifest: IExtensionManifest): boolean;
+    prefersExecuteOnWorkspace(manifest: IExtensionManifest): boolean;
+    prefersExecuteOnWeb(manifest: IExtensionManifest): boolean;
+    canExecuteOnUI(manifest: IExtensionManifest): boolean;
+    canExecuteOnWorkspace(manifest: IExtensionManifest): boolean;
+    canExecuteOnWeb(manifest: IExtensionManifest): boolean;
+    getExtensionKind(manifest: IExtensionManifest): ExtensionKind[];
+    getUserConfiguredExtensionKind(extensionIdentifier: IExtensionIdentifier): ExtensionKind[] | undefined;
+    getExtensionUntrustedWorkspaceSupportType(manifest: IExtensionManifest): ExtensionUntrustedWorkspaceSupportType;
+    getExtensionVirtualWorkspaceSupportType(manifest: IExtensionManifest): ExtensionVirtualWorkspaceSupportType;
+}
+
+export { IExtensionManifestPropertiesService };

package/vscode/src/vs/workbench/services/extensions/common/extensionRunningLocationTracker.d.ts

@@ -0,0 +1,45 @@
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
+import { ExtensionKind } from '../../../../platform/environment/common/environment.js';
+import { ExtensionIdentifier, IExtensionDescription, ExtensionIdentifierMap } from '../../../../platform/extensions/common/extensions.js';
+import { ILogService } from '../../../../platform/log/common/log.service.js';
+import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.service.js';
+import { IReadOnlyExtensionDescriptionRegistry } from './extensionDescriptionRegistry.js';
+import { IExtensionHostKindPicker, ExtensionHostKind } from './extensionHostKind.js';
+import { IExtensionHostManager } from './extensionHostManagers.js';
+import { IExtensionManifestPropertiesService } from './extensionManifestPropertiesService.service.js';
+import { ExtensionRunningLocation } from './extensionRunningLocation.js';
+
+declare class ExtensionRunningLocationTracker {
+    private readonly _registry;
+    private readonly _extensionHostKindPicker;
+    private readonly _environmentService;
+    private readonly _configurationService;
+    private readonly _logService;
+    private readonly _extensionManifestPropertiesService;
+    private _runningLocation;
+    private _maxLocalProcessAffinity;
+    private _maxLocalWebWorkerAffinity;
+    get maxLocalProcessAffinity(): number;
+    get maxLocalWebWorkerAffinity(): number;
+    constructor(_registry: IReadOnlyExtensionDescriptionRegistry, _extensionHostKindPicker: IExtensionHostKindPicker, _environmentService: IWorkbenchEnvironmentService, _configurationService: IConfigurationService, _logService: ILogService, _extensionManifestPropertiesService: IExtensionManifestPropertiesService);
+    set(extensionId: ExtensionIdentifier, runningLocation: ExtensionRunningLocation): void;
+    readExtensionKinds(extensionDescription: IExtensionDescription): ExtensionKind[];
+    getRunningLocation(extensionId: ExtensionIdentifier): ExtensionRunningLocation | null;
+    filterByRunningLocation(extensions: readonly IExtensionDescription[], desiredRunningLocation: ExtensionRunningLocation): IExtensionDescription[];
+    filterByExtensionHostKind(extensions: readonly IExtensionDescription[], desiredExtensionHostKind: ExtensionHostKind): IExtensionDescription[];
+    filterByExtensionHostManager(extensions: readonly IExtensionDescription[], extensionHostManager: IExtensionHostManager): IExtensionDescription[];
+    private _computeAffinity;
+    computeRunningLocation(localExtensions: IExtensionDescription[], remoteExtensions: IExtensionDescription[], isInitialAllocation: boolean): ExtensionIdentifierMap<ExtensionRunningLocation | null>;
+    private _doComputeRunningLocation;
+    initializeRunningLocation(localExtensions: IExtensionDescription[], remoteExtensions: IExtensionDescription[]): void;
+    /**
+     * Returns the running locations for the removed extensions.
+     */
+    deltaExtensions(toAdd: IExtensionDescription[], toRemove: ExtensionIdentifier[]): ExtensionIdentifierMap<ExtensionRunningLocation | null>;
+    /**
+     * Update `this._runningLocation` with running locations for newly enabled/installed extensions.
+     */
+    private _updateRunningLocationForAddedExtensions;
+}
+
+export { ExtensionRunningLocationTracker };

package/vscode/src/vs/workbench/services/extensions/common/extensionsProposedApi.d.ts

@@ -0,0 +1,17 @@
+import { IExtensionDescription } from '../../../../platform/extensions/common/extensions.js';
+import { ILogService } from '../../../../platform/log/common/log.service.js';
+import { IProductService } from '../../../../platform/product/common/productService.service.js';
+import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.service.js';
+
+declare class ExtensionsProposedApi {
+    private readonly _logService;
+    private readonly _environmentService;
+    private readonly _envEnablesProposedApiForAll;
+    private readonly _envEnabledExtensions;
+    private readonly _productEnabledExtensions;
+    constructor(_logService: ILogService, _environmentService: IWorkbenchEnvironmentService, productService: IProductService);
+    updateEnabledApiProposals(extensions: IExtensionDescription[]): void;
+    private doUpdateEnabledApiProposals;
+}
+
+export { ExtensionsProposedApi };

package/vscode/src/vs/workbench/services/extensions/common/rpcProtocol.d.ts

@@ -0,0 +1,6 @@
+declare const enum ResponsiveState {
+    Responsive = 0,
+    Unresponsive = 1
+}
+
+export { ResponsiveState };

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

@@ -0,0 +1,50 @@
+import { URI } from '../../../../base/common/uri.js';
+import { TunnelProtocol } from '../../../../platform/tunnel/common/tunnel.js';
+import { TunnelPrivacy } from '../../../../platform/remote/common/remoteAuthorityResolver.js';
+import '../../../../editor/editor.api.js';
+import { IExtensionDescription } from '../../../../platform/extensions/common/extensions.js';
+import { TunnelSource } from './tunnelModel.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;
+}
+
+export { type HelpInformation, type ITunnelItem, TunnelEditId, TunnelType };

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

@@ -0,0 +1,40 @@
+import { ServiceIdentifier } from '../../../../platform/instantiation/common/instantiation.js';
+import { Event } from '../../../../base/common/event.js';
+import { RemoteTunnel } from '../../../../platform/tunnel/common/tunnel.js';
+import { IDisposable } from '../../../../base/common/lifecycle.js';
+import { IEditableData } from '../../../common/views.js';
+import { TunnelInformation } from '../../../../platform/remote/common/remoteAuthorityResolver.js';
+import { TunnelModel, TunnelProperties, Attributes, TunnelCloseReason, CandidatePort } from './tunnelModel.js';
+import { IExtensionPointUser } from '../../extensions/common/extensionsRegistry.js';
+import { HelpInformation, ITunnelItem, TunnelEditId } from './remoteExplorerService.js';
+
+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 { IRemoteExplorerService };

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

@@ -0,0 +1,185 @@
+import { Event } from '../../../../base/common/event.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { URI } from '../../../../base/common/uri.js';
+import { ConfigurationTarget } from '../../../../platform/configuration/common/configuration.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
+import { IDialogService } from '../../../../platform/dialogs/common/dialogs.service.js';
+import { ILogService } from '../../../../platform/log/common/log.service.js';
+import { TunnelDescription } from '../../../../platform/remote/common/remoteAuthorityResolver.js';
+import { IRemoteAuthorityResolverService } from '../../../../platform/remote/common/remoteAuthorityResolver.service.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.service.js';
+import { TunnelProtocol, RemoteTunnel, PortAttributesProvider, TunnelPrivacyId, ProvidedOnAutoForward } from '../../../../platform/tunnel/common/tunnel.js';
+import { ITunnelService } from '../../../../platform/tunnel/common/tunnel.service.js';
+import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.service.js';
+import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.service.js';
+import { IExtensionService } from '../../extensions/common/extensions.service.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.service.js';
+
+interface Tunnel {
+    remoteHost: string;
+    remotePort: number;
+    localAddress: string;
+    localUri: URI;
+    protocol: TunnelProtocol;
+    localPort?: number;
+    name?: string;
+    closeable?: boolean;
+    privacy: TunnelPrivacyId | string;
+    runningProcess: string | undefined;
+    hasRunningProcess?: boolean;
+    pid: number | undefined;
+    source: {
+        source: TunnelSource;
+        description: string;
+    };
+}
+declare enum TunnelCloseReason {
+    Other = "Other",
+    User = "User",
+    AutoForwardEnd = "AutoForwardEnd"
+}
+declare enum TunnelSource {
+    User = 0,
+    Auto = 1,
+    Extension = 2
+}
+interface TunnelProperties {
+    remote: {
+        host: string;
+        port: number;
+    };
+    local?: number;
+    name?: string;
+    source?: {
+        source: TunnelSource;
+        description: string;
+    };
+    elevateIfNeeded?: boolean;
+    privacy?: string;
+}
+interface CandidatePort {
+    host: string;
+    port: number;
+    detail?: string;
+    pid?: number;
+}
+declare enum OnPortForward {
+    Notify = "notify",
+    OpenBrowser = "openBrowser",
+    OpenBrowserOnce = "openBrowserOnce",
+    OpenPreview = "openPreview",
+    Silent = "silent",
+    Ignore = "ignore"
+}
+interface Attributes {
+    label: string | undefined;
+    onAutoForward: OnPortForward | undefined;
+    elevateIfNeeded: boolean | undefined;
+    requireLocalPort: boolean | undefined;
+    protocol: TunnelProtocol | undefined;
+}
+declare class PortsAttributes extends Disposable {
+    private readonly configurationService;
+    private static SETTING;
+    private static DEFAULTS;
+    private static RANGE;
+    private static HOST_AND_PORT;
+    private portsAttributes;
+    private defaultPortAttributes;
+    private _onDidChangeAttributes;
+    readonly onDidChangeAttributes: Event<void>;
+    constructor(configurationService: IConfigurationService);
+    private updateAttributes;
+    getAttributes(port: number, host: string, commandLine?: string): Attributes | undefined;
+    private hasStartEnd;
+    private hasHostAndPort;
+    private findNextIndex;
+    private readSetting;
+    private sortAttributes;
+    private getOtherAttributes;
+    static providedActionToAction(providedAction: ProvidedOnAutoForward | undefined): OnPortForward | undefined;
+    addAttributes(port: number, attributes: Partial<Attributes>, target: ConfigurationTarget): Promise<void>;
+}
+declare class TunnelModel extends Disposable {
+    private readonly tunnelService;
+    private readonly storageService;
+    private readonly configurationService;
+    private readonly environmentService;
+    private readonly remoteAuthorityResolverService;
+    private readonly workspaceContextService;
+    private readonly logService;
+    private readonly dialogService;
+    private readonly extensionService;
+    private readonly contextKeyService;
+    readonly forwarded: Map<string, Tunnel>;
+    private readonly inProgress;
+    readonly detected: Map<string, Tunnel>;
+    private remoteTunnels;
+    private _onForwardPort;
+    onForwardPort: Event<Tunnel | void>;
+    private _onClosePort;
+    onClosePort: Event<{
+        host: string;
+        port: number;
+    }>;
+    private _onPortName;
+    onPortName: Event<{
+        host: string;
+        port: number;
+    }>;
+    private _candidates;
+    private _onCandidatesChanged;
+    onCandidatesChanged: Event<Map<string, {
+        host: string;
+        port: number;
+    }>>;
+    private _candidateFilter;
+    private tunnelRestoreValue;
+    private _onEnvironmentTunnelsSet;
+    onEnvironmentTunnelsSet: Event<void>;
+    private _environmentTunnelsSet;
+    readonly configPortsAttributes: PortsAttributes;
+    private restoreListener;
+    private knownPortsRestoreValue;
+    private restoreComplete;
+    private onRestoreComplete;
+    private unrestoredExtensionTunnels;
+    private sessionCachedProperties;
+    private portAttributesProviders;
+    constructor(tunnelService: ITunnelService, storageService: IStorageService, configurationService: IConfigurationService, environmentService: IWorkbenchEnvironmentService, remoteAuthorityResolverService: IRemoteAuthorityResolverService, workspaceContextService: IWorkspaceContextService, logService: ILogService, dialogService: IDialogService, extensionService: IExtensionService, contextKeyService: IContextKeyService);
+    private extensionHasActivationEvent;
+    private checkExtensionActivationEvents;
+    private onTunnelClosed;
+    private makeLocalUri;
+    private addStorageKeyPostfix;
+    private getTunnelRestoreStorageKey;
+    private getRestoreExpirationStorageKey;
+    private getTunnelRestoreValue;
+    restoreForwarded(): Promise<void>;
+    private cleanupExpiredTunnelsForRestore;
+    private storeForwarded;
+    private mismatchCooldown;
+    private showPortMismatchModalIfNeeded;
+    forward(tunnelProperties: TunnelProperties, attributes?: Attributes | null): Promise<RemoteTunnel | string | undefined>;
+    private doForward;
+    private mergeCachedAndUnrestoredProperties;
+    private mergeAttributesIntoExistingTunnel;
+    name(host: string, port: number, name: string): Promise<void>;
+    close(host: string, port: number, reason: TunnelCloseReason): Promise<void>;
+    address(host: string, port: number): string | undefined;
+    get environmentTunnelsSet(): boolean;
+    addEnvironmentTunnels(tunnels: TunnelDescription[] | undefined): void;
+    setCandidateFilter(filter: ((candidates: CandidatePort[]) => Promise<CandidatePort[]>) | undefined): void;
+    setCandidates(candidates: CandidatePort[]): Promise<void>;
+    private updateInResponseToCandidates;
+    get candidates(): CandidatePort[];
+    get candidatesOrUndefined(): CandidatePort[] | undefined;
+    private updateAttributes;
+    getAttributes(forwardedPorts: {
+        host: string;
+        port: number;
+    }[], checkProviders?: boolean): Promise<Map<number, Attributes> | undefined>;
+    addAttributesProvider(provider: PortAttributesProvider): void;
+}
+
+export { type Attributes, type CandidatePort, OnPortForward, PortsAttributes, type Tunnel, TunnelCloseReason, TunnelModel, type TunnelProperties, TunnelSource };

package/vscode/src/vs/workbench/services/storage/browser/storageService.d.ts

@@ -0,0 +1,41 @@
+import { IStorage } from '../../../../base/parts/storage/common/storage.js';
+import { ILogService } from '../../../../platform/log/common/log.service.js';
+import { AbstractStorageService, StorageScope } from '../../../../platform/storage/common/storage.js';
+import { IUserDataProfile } from '../../../../platform/userDataProfile/common/userDataProfile.js';
+import { IAnyWorkspaceIdentifier } from '../../../../platform/workspace/common/workspace.js';
+import { IUserDataProfileService } from '../../userDataProfile/common/userDataProfile.service.js';
+
+declare class BrowserStorageService extends AbstractStorageService {
+    private workspace;
+    private readonly userDataProfileService;
+    private readonly logService;
+    private static BROWSER_DEFAULT_FLUSH_INTERVAL;
+    private applicationStorage;
+    private applicationStorageDatabase;
+    private readonly applicationStoragePromise;
+    private profileStorage;
+    private profileStorageDatabase;
+    private profileStorageProfile;
+    private readonly profileStorageDisposables;
+    private workspaceStorage;
+    private workspaceStorageDatabase;
+    private readonly workspaceStorageDisposables;
+    get hasPendingUpdate(): boolean;
+    constructor(workspace: IAnyWorkspaceIdentifier, userDataProfileService: IUserDataProfileService, logService: ILogService);
+    private registerListeners;
+    protected doInitialize(): Promise<void>;
+    private createApplicationStorage;
+    private createProfileStorage;
+    private createWorkspaceStorage;
+    private updateIsNew;
+    protected getStorage(scope: StorageScope): IStorage | undefined;
+    protected getLogDetails(scope: StorageScope): string | undefined;
+    protected switchToProfile(toProfile: IUserDataProfile): Promise<void>;
+    protected switchToWorkspace(toWorkspace: IAnyWorkspaceIdentifier, preserveData: boolean): Promise<void>;
+    protected shouldFlushWhenIdle(): boolean;
+    close(): void;
+    clear(): Promise<void>;
+    hasScope(scope: IAnyWorkspaceIdentifier | IUserDataProfile): boolean;
+}
+
+export { BrowserStorageService };

package/vscode/src/vs/workbench/services/textMate/browser/textMateTokenizationFeature.service.d.ts

@@ -0,0 +1,11 @@
+import { ServiceIdentifier } from '../../../../platform/instantiation/common/instantiation.js';
+import { IGrammar } from 'vscode-textmate';
+
+declare const ITextMateTokenizationService: ServiceIdentifier<ITextMateTokenizationService>;
+interface ITextMateTokenizationService {
+    readonly _serviceBrand: undefined;
+    createTokenizer(languageId: string): Promise<IGrammar | null>;
+    startDebugMode(printFn: (str: string) => void, onStop: () => void): void;
+}
+
+export { ITextMateTokenizationService };

package/vscode/src/vs/workbench/services/userData/browser/userDataInit.d.ts

@@ -0,0 +1,11 @@
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+
+interface IUserDataInitializer {
+    requiresInitialization(): Promise<boolean>;
+    whenInitializationFinished(): Promise<void>;
+    initializeRequiredResources(): Promise<void>;
+    initializeInstalledExtensions(instantiationService: IInstantiationService): Promise<void>;
+    initializeOtherResources(instantiationService: IInstantiationService): Promise<void>;
+}
+
+export type { IUserDataInitializer };

package/vscode/src/vs/workbench/services/userData/browser/userDataInit.service.d.ts

@@ -0,0 +1,9 @@
+import { ServiceIdentifier } from '../../../../platform/instantiation/common/instantiation.js';
+import { IUserDataInitializer } from './userDataInit.js';
+
+declare const IUserDataInitializationService: ServiceIdentifier<IUserDataInitializationService>;
+interface IUserDataInitializationService extends IUserDataInitializer {
+    _serviceBrand: any;
+}
+
+export { IUserDataInitializationService };