@codingame/monaco-vscode-api 1.81.2 → 1.81.3

package/dist/vscode/vs/base/browser/broadcast.js

@@ -0,0 +1,52 @@
+import { getErrorMessage } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+class BroadcastDataChannel extends Disposable {
+    constructor(channelName) {
+        super();
+        this.channelName = channelName;
+        this._onDidReceiveData = this._register(( new Emitter()));
+        this.onDidReceiveData = this._onDidReceiveData.event;
+        if ('BroadcastChannel' in window) {
+            try {
+                this.broadcastChannel = ( new BroadcastChannel(channelName));
+                const listener = (event) => {
+                    this._onDidReceiveData.fire(event.data);
+                };
+                this.broadcastChannel.addEventListener('message', listener);
+                this._register(toDisposable(() => {
+                    if (this.broadcastChannel) {
+                        this.broadcastChannel.removeEventListener('message', listener);
+                        this.broadcastChannel.close();
+                    }
+                }));
+            }
+            catch (error) {
+                console.warn('Error while creating broadcast channel. Falling back to localStorage.', getErrorMessage(error));
+            }
+        }
+        if (!this.broadcastChannel) {
+            this.channelName = `BroadcastDataChannel.${channelName}`;
+            this.createBroadcastChannel();
+        }
+    }
+    createBroadcastChannel() {
+        const listener = (event) => {
+            if (event.key === this.channelName && event.newValue) {
+                this._onDidReceiveData.fire(JSON.parse(event.newValue));
+            }
+        };
+        window.addEventListener('storage', listener);
+        this._register(toDisposable(() => window.removeEventListener('storage', listener)));
+    }
+    postData(data) {
+        if (this.broadcastChannel) {
+            this.broadcastChannel.postMessage(data);
+        }
+        else {
+            window.localStorage.removeItem(this.channelName);
+            window.localStorage.setItem(this.channelName, JSON.stringify(data));
+        }
+    }
+}
+export { BroadcastDataChannel };

package/dist/vscode/vs/base/parts/storage/common/storage.d.ts

@@ -1,7 +1,44 @@
+import { Event } from '../../../common/event.js';
+import { IDisposable } from '../../../common/lifecycle.js';
+
 interface IStorageItemsChangeEvent {
     readonly changed?: Map<string, string>;
     readonly deleted?: Set<string>;
 }
+interface IStorageChangeEvent {
+    /**
+     * The `key` of the storage entry that was changed
+     * or was removed.
+     */
+    readonly key: string;
+    /**
+     * A hint how the storage change event was triggered. If
+     * `true`, the storage change was triggered by an external
+     * source, such as:
+     * - another process (for example another window)
+     * - operations such as settings sync or profiles change
+     */
+    readonly external?: boolean;
+}
 type StorageValue = string | boolean | number | undefined | null | object;
+interface IStorage extends IDisposable {
+    readonly onDidChangeStorage: Event<IStorageChangeEvent>;
+    readonly items: Map<string, string>;
+    readonly size: number;
+    init(): Promise<void>;
+    get(key: string, fallbackValue: string): string;
+    get(key: string, fallbackValue?: string): string | undefined;
+    getBoolean(key: string, fallbackValue: boolean): boolean;
+    getBoolean(key: string, fallbackValue?: boolean): boolean | undefined;
+    getNumber(key: string, fallbackValue: number): number;
+    getNumber(key: string, fallbackValue?: number): number | undefined;
+    getObject<T extends object>(key: string, fallbackValue: T): T;
+    getObject<T extends object>(key: string, fallbackValue?: T): T | undefined;
+    set(key: string, value: StorageValue, external?: boolean): Promise<void>;
+    delete(key: string, external?: boolean): Promise<void>;
+    flush(delay?: number): Promise<void>;
+    whenFlushed(): Promise<void>;
+    close(): Promise<void>;
+}
 
-export { IStorageItemsChangeEvent, StorageValue };
+export { IStorage, IStorageChangeEvent, IStorageItemsChangeEvent, StorageValue };

package/dist/vscode/vs/platform/storage/common/storage.d.ts

@@ -1,6 +1,7 @@
 import { ServiceIdentifier } from '../../instantiation/common/instantiation.js';
 import { Event } from '../../../base/common/event.js';
-import { StorageValue } from '../../../base/parts/storage/common/storage.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
+import { StorageValue, IStorageChangeEvent, IStorage } from '../../../base/parts/storage/common/storage.js';
 import { IUserDataProfile } from '../../userDataProfile/common/userDataProfile.js';
 import { IAnyWorkspaceIdentifier } from '../../workspace/common/workspace.js';
 
@@ -216,5 +217,63 @@ interface IStorageTargetChangeEvent {
      */
     readonly scope: StorageScope;
 }
+interface IStorageServiceOptions {
+    readonly flushInterval: number;
+}
+declare abstract class AbstractStorageService extends Disposable implements IStorageService {
+    private readonly options;
+    readonly _serviceBrand: undefined;
+    private static DEFAULT_FLUSH_INTERVAL;
+    private readonly _onDidChangeValue;
+    readonly onDidChangeValue: Event<IStorageValueChangeEvent>;
+    private readonly _onDidChangeTarget;
+    readonly onDidChangeTarget: Event<IStorageTargetChangeEvent>;
+    private readonly _onWillSaveState;
+    readonly onWillSaveState: Event<IWillSaveStateEvent>;
+    private initializationPromise;
+    private readonly flushWhenIdleScheduler;
+    private readonly runFlushWhenIdle;
+    constructor(options?: IStorageServiceOptions);
+    private doFlushWhenIdle;
+    protected shouldFlushWhenIdle(): boolean;
+    protected stopFlushWhenIdle(): void;
+    initialize(): Promise<void>;
+    protected emitDidChangeValue(scope: StorageScope, event: IStorageChangeEvent): void;
+    protected emitWillSaveState(reason: WillSaveStateReason): void;
+    get(key: string, scope: StorageScope, fallbackValue: string): string;
+    get(key: string, scope: StorageScope): string | undefined;
+    getBoolean(key: string, scope: StorageScope, fallbackValue: boolean): boolean;
+    getBoolean(key: string, scope: StorageScope): boolean | undefined;
+    getNumber(key: string, scope: StorageScope, fallbackValue: number): number;
+    getNumber(key: string, scope: StorageScope): number | undefined;
+    getObject(key: string, scope: StorageScope, fallbackValue: object): object;
+    getObject(key: string, scope: StorageScope): object | undefined;
+    storeAll(entries: Array<IStorageEntry>, external: boolean): void;
+    store(key: string, value: StorageValue, scope: StorageScope, target: StorageTarget, external?: boolean): void;
+    remove(key: string, scope: StorageScope, external?: boolean): void;
+    private withPausedEmitters;
+    keys(scope: StorageScope, target: StorageTarget): string[];
+    private updateKeyTarget;
+    private _workspaceKeyTargets;
+    private get workspaceKeyTargets();
+    private _profileKeyTargets;
+    private get profileKeyTargets();
+    private _applicationKeyTargets;
+    private get applicationKeyTargets();
+    private getKeyTargets;
+    private loadKeyTargets;
+    isNew(scope: StorageScope): boolean;
+    flush(reason?: WillSaveStateReason): Promise<void>;
+    log(): Promise<void>;
+    switch(to: IAnyWorkspaceIdentifier | IUserDataProfile, preserveData: boolean): Promise<void>;
+    protected canSwitchProfile(from: IUserDataProfile, to: IUserDataProfile): boolean;
+    protected switchData(oldStorage: Map<string, string>, newStorage: IStorage, scope: StorageScope): void;
+    abstract hasScope(scope: IAnyWorkspaceIdentifier | IUserDataProfile): boolean;
+    protected abstract doInitialize(): Promise<void>;
+    protected abstract getStorage(scope: StorageScope): IStorage | undefined;
+    protected abstract getLogDetails(scope: StorageScope): string | undefined;
+    protected abstract switchToProfile(toProfile: IUserDataProfile, preserveData: boolean): Promise<void>;
+    protected abstract switchToWorkspace(toWorkspace: IAnyWorkspaceIdentifier | IUserDataProfile, preserveData: boolean): Promise<void>;
+}
 
-export { IStorageEntry, IStorageService, IStorageTargetChangeEvent, IStorageValueChangeEvent, IWillSaveStateEvent, StorageScope, StorageTarget, WillSaveStateReason };
+export { AbstractStorageService, IStorageEntry, IStorageService, IStorageServiceOptions, IStorageTargetChangeEvent, IStorageValueChangeEvent, IWillSaveStateEvent, StorageScope, StorageTarget, WillSaveStateReason };

package/dist/vscode/vs/workbench/services/layout/browser/layoutService.js

@@ -1,6 +1,17 @@
 import { refineServiceDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { ILayoutService } from 'monaco-editor/esm/vs/platform/layout/browser/layoutService.js';
 const IWorkbenchLayoutService = refineServiceDecorator(ILayoutService);
+var Parts;
+( (function(Parts) {
+    Parts["TITLEBAR_PART"] = "workbench.parts.titlebar";
+    Parts["BANNER_PART"] = "workbench.parts.banner";
+    Parts["ACTIVITYBAR_PART"] = "workbench.parts.activitybar";
+    Parts["SIDEBAR_PART"] = "workbench.parts.sidebar";
+    Parts["PANEL_PART"] = "workbench.parts.panel";
+    Parts["AUXILIARYBAR_PART"] = "workbench.parts.auxiliarybar";
+    Parts["EDITOR_PART"] = "workbench.parts.editor";
+    Parts["STATUSBAR_PART"] = "workbench.parts.statusbar";
+})(Parts || (Parts = {})));
 function positionToString(position) {
     switch (position) {
         case 0 : return 'left';
@@ -9,4 +20,4 @@ function positionToString(position) {
         default: return 'bottom';
     }
 }
-export { IWorkbenchLayoutService, positionToString };
+export { IWorkbenchLayoutService, Parts, positionToString };

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

@@ -0,0 +1,40 @@
+import { IStorage } from '../../../../base/parts/storage/common/storage.js';
+import { ILogService } from '../../../../platform/log/common/log.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.js';
+
+declare class BrowserStorageService extends AbstractStorageService {
+    private readonly 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;
+    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/dist/vscode/vs/workbench/services/storage/browser/storageService.js

@@ -0,0 +1,278 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { BroadcastDataChannel } from '../../../../base/browser/broadcast.js';
+import { isSafari } from 'monaco-editor/esm/vs/base/browser/browser.js';
+import { IndexedDB } from 'monaco-editor/esm/vs/base/browser/indexedDB.js';
+import { DeferredPromise, Promises } from 'monaco-editor/esm/vs/base/common/async.js';
+import { toErrorMessage } from 'monaco-editor/esm/vs/base/common/errorMessage.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { DisposableStore, Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { Storage, isStorageItemsChangeEvent, InMemoryStorageDatabase } from 'monaco-editor/esm/vs/base/parts/storage/common/storage.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { AbstractStorageService, isProfileUsingDefaultStorage, IS_NEW_KEY } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { isUserDataProfile } from 'monaco-editor/esm/vs/platform/userDataProfile/common/userDataProfile.js';
+let BrowserStorageService = class BrowserStorageService extends AbstractStorageService {
+    static { this.BROWSER_DEFAULT_FLUSH_INTERVAL = 5 * 1000; }
+    get hasPendingUpdate() {
+        return Boolean(this.applicationStorageDatabase?.hasPendingUpdate ||
+            this.profileStorageDatabase?.hasPendingUpdate ||
+            this.workspaceStorageDatabase?.hasPendingUpdate);
+    }
+    constructor(workspace, userDataProfileService, logService) {
+        super({ flushInterval: BrowserStorageService.BROWSER_DEFAULT_FLUSH_INTERVAL });
+        this.workspace = workspace;
+        this.userDataProfileService = userDataProfileService;
+        this.logService = logService;
+        this.applicationStoragePromise = ( new DeferredPromise());
+        this.profileStorageProfile = this.userDataProfileService.currentProfile;
+        this.profileStorageDisposables = this._register(( new DisposableStore()));
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.userDataProfileService.onDidChangeCurrentProfile(e => e.join(this.switchToProfile(e.profile))));
+    }
+    async doInitialize() {
+        await Promises.settled([
+            this.createApplicationStorage(),
+            this.createProfileStorage(this.profileStorageProfile),
+            this.createWorkspaceStorage()
+        ]);
+    }
+    async createApplicationStorage() {
+        const applicationStorageIndexedDB = await IndexedDBStorageDatabase.createApplicationStorage(this.logService);
+        this.applicationStorageDatabase = this._register(applicationStorageIndexedDB);
+        this.applicationStorage = this._register(( new Storage(this.applicationStorageDatabase)));
+        this._register(this.applicationStorage.onDidChangeStorage(e => this.emitDidChangeValue(-1 , e)));
+        await this.applicationStorage.init();
+        this.updateIsNew(this.applicationStorage);
+        this.applicationStoragePromise.complete({ indexedDb: applicationStorageIndexedDB, storage: this.applicationStorage });
+    }
+    async createProfileStorage(profile) {
+        this.profileStorageDisposables.clear();
+        this.profileStorageProfile = profile;
+        if (isProfileUsingDefaultStorage(this.profileStorageProfile)) {
+            const { indexedDb: applicationStorageIndexedDB, storage: applicationStorage } = await this.applicationStoragePromise.p;
+            this.profileStorageDatabase = applicationStorageIndexedDB;
+            this.profileStorage = applicationStorage;
+            this.profileStorageDisposables.add(this.profileStorage.onDidChangeStorage(e => this.emitDidChangeValue(0 , e)));
+        }
+        else {
+            const profileStorageIndexedDB = await IndexedDBStorageDatabase.createProfileStorage(this.profileStorageProfile, this.logService);
+            this.profileStorageDatabase = this.profileStorageDisposables.add(profileStorageIndexedDB);
+            this.profileStorage = this.profileStorageDisposables.add(( new Storage(this.profileStorageDatabase)));
+            this.profileStorageDisposables.add(this.profileStorage.onDidChangeStorage(e => this.emitDidChangeValue(0 , e)));
+            await this.profileStorage.init();
+            this.updateIsNew(this.profileStorage);
+        }
+    }
+    async createWorkspaceStorage() {
+        const workspaceStorageIndexedDB = await IndexedDBStorageDatabase.createWorkspaceStorage(this.workspace.id, this.logService);
+        this.workspaceStorageDatabase = this._register(workspaceStorageIndexedDB);
+        this.workspaceStorage = this._register(( new Storage(this.workspaceStorageDatabase)));
+        this._register(this.workspaceStorage.onDidChangeStorage(e => this.emitDidChangeValue(1 , e)));
+        await this.workspaceStorage.init();
+        this.updateIsNew(this.workspaceStorage);
+    }
+    updateIsNew(storage) {
+        const firstOpen = storage.getBoolean(IS_NEW_KEY);
+        if (firstOpen === undefined) {
+            storage.set(IS_NEW_KEY, true);
+        }
+        else if (firstOpen) {
+            storage.set(IS_NEW_KEY, false);
+        }
+    }
+    getStorage(scope) {
+        switch (scope) {
+            case -1 :
+                return this.applicationStorage;
+            case 0 :
+                return this.profileStorage;
+            default:
+                return this.workspaceStorage;
+        }
+    }
+    getLogDetails(scope) {
+        switch (scope) {
+            case -1 :
+                return this.applicationStorageDatabase?.name;
+            case 0 :
+                return this.profileStorageDatabase?.name;
+            default:
+                return this.workspaceStorageDatabase?.name;
+        }
+    }
+    async switchToProfile(toProfile) {
+        if (!this.canSwitchProfile(this.profileStorageProfile, toProfile)) {
+            return;
+        }
+        const oldProfileStorage = assertIsDefined(this.profileStorage);
+        const oldItems = oldProfileStorage.items;
+        if (oldProfileStorage !== this.applicationStorage) {
+            await oldProfileStorage.close();
+        }
+        await this.createProfileStorage(toProfile);
+        this.switchData(oldItems, assertIsDefined(this.profileStorage), 0 );
+    }
+    async switchToWorkspace(toWorkspace, preserveData) {
+        throw new Error('Migrating storage is currently unsupported in Web');
+    }
+    shouldFlushWhenIdle() {
+        return document.hasFocus() && !this.hasPendingUpdate;
+    }
+    close() {
+        if (isSafari) {
+            this.applicationStorage?.close();
+            this.profileStorageDatabase?.close();
+            this.workspaceStorageDatabase?.close();
+        }
+        this.dispose();
+    }
+    async clear() {
+        for (const scope of [-1 , 0 , 1 ]) {
+            for (const target of [0 , 1 ]) {
+                for (const key of ( this.keys(scope, target))) {
+                    this.remove(key, scope);
+                }
+            }
+            await this.getStorage(scope)?.whenFlushed();
+        }
+        await Promises.settled([
+            this.applicationStorageDatabase?.clear() ?? Promise.resolve(),
+            this.profileStorageDatabase?.clear() ?? Promise.resolve(),
+            this.workspaceStorageDatabase?.clear() ?? Promise.resolve()
+        ]);
+    }
+    hasScope(scope) {
+        if (isUserDataProfile(scope)) {
+            return this.profileStorageProfile.id === scope.id;
+        }
+        return this.workspace.id === scope.id;
+    }
+};
+BrowserStorageService = ( __decorate([
+    ( __param(2, ILogService))
+], BrowserStorageService));
+class InMemoryIndexedDBStorageDatabase extends InMemoryStorageDatabase {
+    constructor() {
+        super(...arguments);
+        this.hasPendingUpdate = false;
+        this.name = 'in-memory-indexedb-storage';
+    }
+    async clear() {
+        (await this.getItems()).clear();
+    }
+    dispose() {
+    }
+}
+class IndexedDBStorageDatabase extends Disposable {
+    static async createApplicationStorage(logService) {
+        return IndexedDBStorageDatabase.create({ id: 'global', broadcastChanges: true }, logService);
+    }
+    static async createProfileStorage(profile, logService) {
+        return IndexedDBStorageDatabase.create({ id: `global-${profile.id}`, broadcastChanges: true }, logService);
+    }
+    static async createWorkspaceStorage(workspaceId, logService) {
+        return IndexedDBStorageDatabase.create({ id: workspaceId }, logService);
+    }
+    static async create(options, logService) {
+        try {
+            const database = ( new IndexedDBStorageDatabase(options, logService));
+            await database.whenConnected;
+            return database;
+        }
+        catch (error) {
+            logService.error(`[IndexedDB Storage ${options.id}] create(): ${toErrorMessage(error, true)}`);
+            return ( new InMemoryIndexedDBStorageDatabase());
+        }
+    }
+    static { this.STORAGE_DATABASE_PREFIX = 'vscode-web-state-db-'; }
+    static { this.STORAGE_OBJECT_STORE = 'ItemTable'; }
+    get hasPendingUpdate() { return !!this.pendingUpdate; }
+    constructor(options, logService) {
+        super();
+        this.logService = logService;
+        this._onDidChangeItemsExternal = this._register(( new Emitter()));
+        this.onDidChangeItemsExternal = this._onDidChangeItemsExternal.event;
+        this.pendingUpdate = undefined;
+        this.name = `${IndexedDBStorageDatabase.STORAGE_DATABASE_PREFIX}${options.id}`;
+        this.broadcastChannel = options.broadcastChanges ? this._register(( new BroadcastDataChannel(this.name))) : undefined;
+        this.whenConnected = this.connect();
+        this.registerListeners();
+    }
+    registerListeners() {
+        if (this.broadcastChannel) {
+            this._register(this.broadcastChannel.onDidReceiveData(data => {
+                if (isStorageItemsChangeEvent(data)) {
+                    this._onDidChangeItemsExternal.fire(data);
+                }
+            }));
+        }
+    }
+    async connect() {
+        try {
+            return await IndexedDB.create(this.name, undefined, [IndexedDBStorageDatabase.STORAGE_OBJECT_STORE]);
+        }
+        catch (error) {
+            this.logService.error(`[IndexedDB Storage ${this.name}] connect() error: ${toErrorMessage(error)}`);
+            throw error;
+        }
+    }
+    async getItems() {
+        const db = await this.whenConnected;
+        function isValid(value) {
+            return typeof value === 'string';
+        }
+        return db.getKeyValues(IndexedDBStorageDatabase.STORAGE_OBJECT_STORE, isValid);
+    }
+    async updateItems(request) {
+        let didUpdate = false;
+        this.pendingUpdate = this.doUpdateItems(request);
+        try {
+            didUpdate = await this.pendingUpdate;
+        }
+        finally {
+            this.pendingUpdate = undefined;
+        }
+        if (this.broadcastChannel && didUpdate) {
+            const event = {
+                changed: request.insert,
+                deleted: request.delete
+            };
+            this.broadcastChannel.postData(event);
+        }
+    }
+    async doUpdateItems(request) {
+        const toInsert = request.insert;
+        const toDelete = request.delete;
+        if ((!toInsert && !toDelete) || (toInsert?.size === 0 && toDelete?.size === 0)) {
+            return false;
+        }
+        const db = await this.whenConnected;
+        await db.runInTransaction(IndexedDBStorageDatabase.STORAGE_OBJECT_STORE, 'readwrite', objectStore => {
+            const requests = [];
+            if (toInsert) {
+                for (const [key, value] of toInsert) {
+                    requests.push(objectStore.put(value, key));
+                }
+            }
+            if (toDelete) {
+                for (const key of toDelete) {
+                    requests.push(objectStore.delete(key));
+                }
+            }
+            return requests;
+        });
+        return true;
+    }
+    async close() {
+        const db = await this.whenConnected;
+        await this.pendingUpdate;
+        return db.close();
+    }
+    async clear() {
+        const db = await this.whenConnected;
+        await db.runInTransaction(IndexedDBStorageDatabase.STORAGE_OBJECT_STORE, 'readwrite', objectStore => objectStore.clear());
+    }
+}
+export { BrowserStorageService, IndexedDBStorageDatabase };

package/dist/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.d.ts

@@ -0,0 +1,19 @@
+import { ServiceIdentifier } from '../../../../platform/instantiation/common/instantiation.js';
+import { Event } from '../../../../base/common/event.js';
+import { IUserDataProfile } from '../../../../platform/userDataProfile/common/userDataProfile.js';
+
+interface DidChangeUserDataProfileEvent {
+    readonly previous: IUserDataProfile;
+    readonly profile: IUserDataProfile;
+    join(promise: Promise<void>): void;
+}
+declare const IUserDataProfileService: ServiceIdentifier<IUserDataProfileService>;
+interface IUserDataProfileService {
+    readonly _serviceBrand: undefined;
+    readonly currentProfile: IUserDataProfile;
+    readonly onDidChangeCurrentProfile: Event<DidChangeUserDataProfileEvent>;
+    updateCurrentProfile(currentProfile: IUserDataProfile): Promise<void>;
+    getShortName(profile: IUserDataProfile): string;
+}
+
+export { DidChangeUserDataProfileEvent, IUserDataProfileService };